target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test(expected = D2RQException.class) public void validateDistinctMembers() { Mapping m = MappingFactory.create() .createDatabase("x").getMapping() .createClassMap("x").getMapping(); MapParser.checkDistinctMapObjects(m.asModel()); } | public static void checkDistinctMapObjects(Model model) throws D2RQException { ensureAllDistinct(model, D2RQ.Database, D2RQ.ClassMap, D2RQ.PropertyBridge, D2RQ.TranslationTable, D2RQ.Translation); } | MapParser { public static void checkDistinctMapObjects(Model model) throws D2RQException { ensureAllDistinct(model, D2RQ.Database, D2RQ.ClassMap, D2RQ.PropertyBridge, D2RQ.TranslationTable, D2RQ.Translation); } } | MapParser { public static void checkDistinctMapObjects(Model model) throws D2RQException { ensureAllDistinct(model, D2RQ.Database, D2RQ.ClassMap, D2RQ.PropertyBridge, D2RQ.TranslationTable, D2RQ.Translation); } } | MapParser { public static void checkDistinctMapObjects(Model model) throws D2RQException { ensureAllDistinct(model, D2RQ.Database, D2RQ.ClassMap, D2RQ.PropertyBridge, D2RQ.TranslationTable, D2RQ.Translation); } static String absolutizeURI(String uri); static void insertBase(Model model, String baseURI); static void validate(Model model); static void fixLegacy(Model model); static void fixLegacyReferences(Model m); static void fixLegacyAdditionalProperty(Model m); static void fixLegacyPropertyBridges(Model m); static void checkVocabulary(Model model); static void checkDistinctMapObjects(Model model); } | MapParser { public static void checkDistinctMapObjects(Model model) throws D2RQException { ensureAllDistinct(model, D2RQ.Database, D2RQ.ClassMap, D2RQ.PropertyBridge, D2RQ.TranslationTable, D2RQ.Translation); } static String absolutizeURI(String uri); static void insertBase(Model model, String baseURI); static void validate(Model model); static void fixLegacy(Model model); static void fixLegacyReferences(Model m); static void fixLegacyAdditionalProperty(Model m); static void fixLegacyPropertyBridges(Model m); static void checkVocabulary(Model model); static void checkDistinctMapObjects(Model model); } |
@Test(expected = D2RQException.class) public void validateExternalResources() { Model m = ModelFactory.createDefaultModel(); m.createResource("x", m.createResource(D2RQ.NS + "XClass")); MapParser.checkVocabulary(m); } | public static void checkVocabulary(Model model) throws D2RQException { new VocabularySummarizer(D2RQ.class).assertNoUndefinedTerms(model, D2RQException.MAPPING_UNKNOWN_D2RQ_PROPERTY, D2RQException.MAPPING_UNKNOWN_D2RQ_CLASS); } | MapParser { public static void checkVocabulary(Model model) throws D2RQException { new VocabularySummarizer(D2RQ.class).assertNoUndefinedTerms(model, D2RQException.MAPPING_UNKNOWN_D2RQ_PROPERTY, D2RQException.MAPPING_UNKNOWN_D2RQ_CLASS); } } | MapParser { public static void checkVocabulary(Model model) throws D2RQException { new VocabularySummarizer(D2RQ.class).assertNoUndefinedTerms(model, D2RQException.MAPPING_UNKNOWN_D2RQ_PROPERTY, D2RQException.MAPPING_UNKNOWN_D2RQ_CLASS); } } | MapParser { public static void checkVocabulary(Model model) throws D2RQException { new VocabularySummarizer(D2RQ.class).assertNoUndefinedTerms(model, D2RQException.MAPPING_UNKNOWN_D2RQ_PROPERTY, D2RQException.MAPPING_UNKNOWN_D2RQ_CLASS); } static String absolutizeURI(String uri); static void insertBase(Model model, String baseURI); static void validate(Model model); static void fixLegacy(Model model); static void fixLegacyReferences(Model m); static void fixLegacyAdditionalProperty(Model m); static void fixLegacyPropertyBridges(Model m); static void checkVocabulary(Model model); static void checkDistinctMapObjects(Model model); } | MapParser { public static void checkVocabulary(Model model) throws D2RQException { new VocabularySummarizer(D2RQ.class).assertNoUndefinedTerms(model, D2RQException.MAPPING_UNKNOWN_D2RQ_PROPERTY, D2RQException.MAPPING_UNKNOWN_D2RQ_CLASS); } static String absolutizeURI(String uri); static void insertBase(Model model, String baseURI); static void validate(Model model); static void fixLegacy(Model model); static void fixLegacyReferences(Model m); static void fixLegacyAdditionalProperty(Model m); static void fixLegacyPropertyBridges(Model m); static void checkVocabulary(Model model); static void checkDistinctMapObjects(Model model); } |
@Test public void testSimple() { Pattern pattern = new Pattern("foo@@table.col1@@baz"); Assert.assertEquals("foo1baz", pattern.makeValue(row("1"))); } | @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testNull() { Pattern pattern = new Pattern("foo@@table.col1@@bar@@table.col2@@baz"); Assert.assertNull(pattern.makeValue(row("123"))); } | @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testMatches() { Pattern p = new Pattern("http: Assert.assertTrue(matches(p, "http: } | public boolean matches(String value) { return !valueExpression(value).isFalse(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testMatchesTrivialPattern() { Pattern p = new Pattern("foobar"); assertPatternValues(p, "foobar", new HashMap<>()); Assert.assertFalse(matches(p, "fooba")); Assert.assertFalse(matches(p, "foobarb")); Assert.assertFalse(matches(p, "oobar")); Assert.assertFalse(matches(p, "ffoobar")); Assert.assertFalse(matches(p, null)); } | public boolean matches(String value) { return !valueExpression(value).isFalse(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testMatchesMiniPattern() { Pattern p = new Pattern("@@table.col1@@"); Map<String, String> map = new HashMap<>(); map.put("table.col1", ""); assertPatternValues(p, "", map); map.put("table.col1", "a"); assertPatternValues(p, "a", map); map.put("table.col1", "xyz"); assertPatternValues(p, "xyz", map); Assert.assertFalse(matches(p, null)); } | public boolean matches(String value) { return !valueExpression(value).isFalse(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testMagicRegexCharactersCauseNoProblems() { Pattern p = new Pattern("(foo|bar)@@table.col1@@"); Map<String, String> map = new HashMap<>(); map.put("table.col1", "1"); assertPatternValues(p, "(foo|bar)1", map); Assert.assertFalse(matches(p, "foo1")); } | public boolean matches(String value) { return !valueExpression(value).isFalse(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testMatchesOneColumnPattern() { Pattern p = new Pattern("foo@@table.col1@@bar"); Map<String, String> map = new HashMap<>(); map.put("table.col1", "1"); assertPatternValues(p, "foo1bar", map); map.put("table.col1", ""); assertPatternValues(p, "foobar", map); map.put("table.col1", "foofoobarbar"); assertPatternValues(p, "foofoofoobarbarbar", map); Assert.assertFalse(matches(p, "fooba")); Assert.assertFalse(matches(p, "barfoo")); Assert.assertFalse(matches(p, "fobar")); } | public boolean matches(String value) { return !valueExpression(value).isFalse(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testMatchesTwoColumnPattern() { Pattern p = new Pattern("foo@@table.col1@@-@@table.col2@@baz"); Map<String, String> map = new HashMap<>(); map.put("table.col1", ""); map.put("table.col2", ""); assertPatternValues(p, "foo-baz", map); map.put("table.col1", "1"); map.put("table.col2", "2"); assertPatternValues(p, "foo1-2baz", map); map.put("table.col1", "baz"); map.put("table.col2", "foo"); assertPatternValues(p, "foobaz-foobaz", map); map.put("table.col1", "XYZ"); map.put("table.col2", "XYZ-2"); assertPatternValues(p, "fooXYZ-XYZ-2baz", map); Assert.assertFalse(matches(p, "foo1-")); Assert.assertFalse(matches(p, "foobaz-")); Assert.assertFalse(matches(p, "foo1-2baz3")); } | public boolean matches(String value) { return !valueExpression(value).isFalse(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testEmptyConjunctionIsTrue() { Assert.assertEquals(Expression.TRUE, Conjunction.create(Collections.emptySet())); } | public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } |
@Test public void testMatchesPatternStartingWithColumn() { Pattern p = new Pattern("@@table.col1@@bar@@table.col2@@baz"); Map<String, String> map = new HashMap<>(); map.put("table.col1", ""); map.put("table.col2", ""); assertPatternValues(p, "barbaz", map); map.put("table.col1", "1"); map.put("table.col2", "2"); assertPatternValues(p, "1bar2baz", map); map.put("table.col1", "baz"); map.put("table.col2", "foo"); assertPatternValues(p, "bazbarfoobaz", map); Assert.assertFalse(matches(p, "1bar")); Assert.assertFalse(matches(p, "bazbar")); Assert.assertFalse(matches(p, "1bar2baz3")); } | public boolean matches(String value) { return !valueExpression(value).isFalse(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPartsIteratorSingleLiteral() { Iterator<Object> it = new Pattern("foo").partsIterator(); Assert.assertTrue(it.hasNext()); Assert.assertEquals("foo", it.next()); Assert.assertFalse(it.hasNext()); } | public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPartsIteratorFirstLiteralThenColumn() { Iterator<Object> it = new Pattern("foo@@table.col1@@").partsIterator(); Assert.assertTrue(it.hasNext()); Assert.assertEquals("foo", it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals(col1, it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals("", it.next()); Assert.assertFalse(it.hasNext()); } | public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPartsIteratorFirstColumnThenLiteral() { Iterator<Object> it = new Pattern("@@table.col1@@foo").partsIterator(); Assert.assertTrue(it.hasNext()); Assert.assertEquals("", it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals(col1, it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals("foo", it.next()); Assert.assertFalse(it.hasNext()); } | public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPartsIteratorSeveralColumns() { Iterator<Object> it = new Pattern("foo@@table.col1@@bar@@table.col2@@").partsIterator(); Assert.assertTrue(it.hasNext()); Assert.assertEquals("foo", it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals(col1, it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals("bar", it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals(col2, it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals("", it.next()); Assert.assertFalse(it.hasNext()); } | public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPartsIteratorAdjacentColumns() { Iterator<Object> it = new Pattern("@@table.col1@@@@table.col2@@").partsIterator(); Assert.assertTrue(it.hasNext()); Assert.assertEquals("", it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals(col1, it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals("", it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals(col2, it.next()); Assert.assertTrue(it.hasNext()); Assert.assertEquals("", it.next()); Assert.assertFalse(it.hasNext()); } | public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public Iterator<Object> partsIterator() { return new Iterator<Object>() { private int i = 0; @Override public boolean hasNext() { return i < columns.size() + literalParts.size() + 1; } @Override public Object next() { i++; if (i == 1) { return firstLiteralPart; } else if (i % 2 == 0) { return columns.get(i / 2 - 1); } return literalParts.get(i / 2 - 1); } @Override public void remove() { throw new UnsupportedOperationException(); } }; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testToString() { Assert.assertEquals("Pattern(foo@@table.col1@@)", new Pattern("foo@@table.col1@@").toString()); } | @Override public String toString() { return "Pattern(" + this.pattern + ")"; } | Pattern implements ValueMaker { @Override public String toString() { return "Pattern(" + this.pattern + ")"; } } | Pattern implements ValueMaker { @Override public String toString() { return "Pattern(" + this.pattern + ")"; } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public String toString() { return "Pattern(" + this.pattern + ")"; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public String toString() { return "Pattern(" + this.pattern + ")"; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testSamePatternsAreEqual() { Pattern p1 = new Pattern("foo@@table.col1@@"); Pattern p2 = new Pattern("foo@@table.col1@@"); Assert.assertEquals(p1, p2); Assert.assertEquals(p2, p1); Assert.assertEquals(p1.hashCode(), p2.hashCode()); } | @Override public int hashCode() { return this.pattern.hashCode(); } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPatternsWithDifferentColumnsAreNotEqual() { Pattern p1 = new Pattern("foo@@table.col1@@"); Pattern p2 = new Pattern("foo@@table.col2@@"); Assert.assertNotEquals(p1, p2); Assert.assertNotEquals(p2, p1); Assert.assertNotEquals(p1.hashCode(), p2.hashCode()); } | @Override public int hashCode() { return this.pattern.hashCode(); } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPatternsWithDifferentLiteralPartsAreNotEqual() { Pattern p1 = new Pattern("foo@@table.col1@@"); Pattern p2 = new Pattern("bar@@table.col1@@"); Assert.assertNotEquals(p1, p2); Assert.assertNotEquals(p2, p1); Assert.assertNotEquals(p1.hashCode(), p2.hashCode()); } | @Override public int hashCode() { return this.pattern.hashCode(); } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public int hashCode() { return this.pattern.hashCode(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testSingletonConjunctionIsSelf() { Expression e = SQLExpression.create("foo"); Assert.assertEquals(e, Conjunction.create(Collections.singleton(e))); } | public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } |
@Test public void testIdenticalPatternsAreCompatible() { Pattern p1 = new Pattern("foo@@table.col1@@"); Pattern p2 = new Pattern("foo@@table.col1@@"); Assert.assertTrue(p1.isEquivalentTo(p2)); Assert.assertTrue(p2.isEquivalentTo(p1)); } | public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPatternsWithDifferentColumnNamesAreCompatible() { Pattern p1 = new Pattern("foo@@table.col1@@"); Pattern p2 = new Pattern("foo@@table.col2@@"); Assert.assertTrue(p1.isEquivalentTo(p2)); Assert.assertTrue(p2.isEquivalentTo(p1)); } | public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPatternsWithDifferentLiteralPartsAreNotCompatible() { Pattern p1 = new Pattern("foo@@table.col1@@"); Pattern p2 = new Pattern("bar@@table.col1@@"); Assert.assertFalse(p1.isEquivalentTo(p2)); Assert.assertFalse(p2.isEquivalentTo(p1)); } | public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testMultiColumnPatternsWithDifferentLiteralPartsAreNotCompatible() { Pattern p1 = new Pattern("foo@@table.col1@@bar@@table.col2@@abc"); Pattern p2 = new Pattern("foo@@table.col1@@bar@@table.col2@@xyz"); Assert.assertFalse(p1.isEquivalentTo(p2)); Assert.assertFalse(p2.isEquivalentTo(p1)); } | public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean isEquivalentTo(Pattern p) { return this.firstLiteralPart.equals(p.firstLiteralPart) && this.literalParts.equals(p.literalParts) && this.columnFunctions.equals(p.columnFunctions); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testLiteralPatternsMatchTrivialRegex() { Assert.assertTrue(new Pattern("asdf").literalPartsMatchRegex(".*")); } | public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testLiteralPatternsDontMatchTrivialRegex() { Assert.assertFalse(new Pattern("asdf").literalPartsMatchRegex("foo")); } | public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testLiteralPatternRegexIsAnchored() { Assert.assertFalse(new Pattern("aaa").literalPartsMatchRegex("b*")); } | public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testLiteralPatternRegexMultipleParts() { Assert.assertTrue(new Pattern("aaa@@aaa.aaa@@aaa").literalPartsMatchRegex("aaa")); } | public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testLiteralPatternRegexMatchesOnlyLiteralParts() { Assert.assertTrue(new Pattern("aaa@@bbb.ccc@@aaa").literalPartsMatchRegex("a+")); } | public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean literalPartsMatchRegex(String regex) { if (!this.firstLiteralPart.matches(regex)) { return false; } for (String literalPart : literalParts) { if (!literalPart.matches(regex)) { return false; } } return true; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPatternURLEncode() { Pattern p = new Pattern("aaa@@table.col1|urlencode@@bbb"); assertPattern("aaax+ybbb", p.makeValue(row("x y"))); assertPatternValues(p, "aaax+ybbb", Collections.singletonMap("table.col1", "x y")); } | @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testToString() { Assert.assertEquals("Conjunction(SQL(papers.publish = 1), SQL(papers.rating > 4))", conjunction12.toString()); } | @Override public String toString() { List<String> fragments = new ArrayList<>(this.expressions.size()); for (Expression expression : expressions) { fragments.add(expression.toString()); } Collections.sort(fragments); StringBuilder result = new StringBuilder("Conjunction("); Iterator<String> it = fragments.iterator(); while (it.hasNext()) { String fragment = it.next(); result.append(fragment); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } | Conjunction extends Expression { @Override public String toString() { List<String> fragments = new ArrayList<>(this.expressions.size()); for (Expression expression : expressions) { fragments.add(expression.toString()); } Collections.sort(fragments); StringBuilder result = new StringBuilder("Conjunction("); Iterator<String> it = fragments.iterator(); while (it.hasNext()) { String fragment = it.next(); result.append(fragment); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } } | Conjunction extends Expression { @Override public String toString() { List<String> fragments = new ArrayList<>(this.expressions.size()); for (Expression expression : expressions) { fragments.add(expression.toString()); } Collections.sort(fragments); StringBuilder result = new StringBuilder("Conjunction("); Iterator<String> it = fragments.iterator(); while (it.hasNext()) { String fragment = it.next(); result.append(fragment); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } private Conjunction(Set<Expression> expressions); } | Conjunction extends Expression { @Override public String toString() { List<String> fragments = new ArrayList<>(this.expressions.size()); for (Expression expression : expressions) { fragments.add(expression.toString()); } Collections.sort(fragments); StringBuilder result = new StringBuilder("Conjunction("); Iterator<String> it = fragments.iterator(); while (it.hasNext()) { String fragment = it.next(); result.append(fragment); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } | Conjunction extends Expression { @Override public String toString() { List<String> fragments = new ArrayList<>(this.expressions.size()); for (Expression expression : expressions) { fragments.add(expression.toString()); } Collections.sort(fragments); StringBuilder result = new StringBuilder("Conjunction("); Iterator<String> it = fragments.iterator(); while (it.hasNext()) { String fragment = it.next(); result.append(fragment); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } |
@Test public void testPatternEncode() { Pattern p = new Pattern("aaa@@table.col1|encode@@bbb"); assertPattern("aaahello%20world%21bbb", p.makeValue(row("hello world!"))); assertPattern("aaa%3A%3B%3C%3D%3E%3F%40bbb", p.makeValue(row(":;<=>?@"))); assertPattern("aaa%5B%5C%5D%5E%60bbb", p.makeValue(row("[\\]^`"))); assertPatternValues(p, "aaa%7B%7C%7Dbbb", Collections.singletonMap("table.col1", "{|}")); } | @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPatternURLEncodeIllegal() { Pattern p = new Pattern("@@table.col1|urlencode@@"); Assert.assertFalse(matches(p, "%")); } | public boolean matches(String value) { return !valueExpression(value).isFalse(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public boolean matches(String value) { return !valueExpression(value).isFalse(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPatternURLify() { Pattern p = new Pattern("aaa@@table.col1|urlify@@bbb"); assertPattern("aaax_ybbb", p.makeValue(row("x y"))); assertPatternValues(p, "aaax_ybbb", Collections.singletonMap("table.col1", "x y")); } | @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testPatternURLifyEscapeUnderscore() { Pattern p = new Pattern("aaa@@table.col1|urlify@@bbb"); assertPattern("aaax%5Fybbb", p.makeValue(row("x_y"))); assertPatternValues(p, "aaax%5Fybbb", Collections.singletonMap("table.col1", "x_y")); } | @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { @Override public String makeValue(ResultRow row) { int index = 0; StringBuilder result = new StringBuilder(this.firstLiteralPart); while (index < this.columns.size()) { Attribute column = columns.get(index); ColumnFunction function = columnFunctions.get(index); String value = row.get(column); if (value == null) { return null; } value = function.encode(value); if (value == null) { return null; } result.append(value); result.append(this.literalParts.get(index)); index++; } return result.toString(); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testTrivialPatternFirstPart() { Assert.assertEquals("aaa", new Pattern("aaa").firstLiteralPart()); } | public String firstLiteralPart() { return firstLiteralPart; } | Pattern implements ValueMaker { public String firstLiteralPart() { return firstLiteralPart; } } | Pattern implements ValueMaker { public String firstLiteralPart() { return firstLiteralPart; } Pattern(String pattern); } | Pattern implements ValueMaker { public String firstLiteralPart() { return firstLiteralPart; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public String firstLiteralPart() { return firstLiteralPart; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testTrivialPatternLastPart() { Assert.assertEquals("aaa", new Pattern("aaa").lastLiteralPart()); } | public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } | Pattern implements ValueMaker { public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } } | Pattern implements ValueMaker { public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } Pattern(String pattern); } | Pattern implements ValueMaker { public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testEmptyFirstPart() { Assert.assertEquals("", new Pattern("@@table.col1@@aaa").firstLiteralPart()); } | public String firstLiteralPart() { return firstLiteralPart; } | Pattern implements ValueMaker { public String firstLiteralPart() { return firstLiteralPart; } } | Pattern implements ValueMaker { public String firstLiteralPart() { return firstLiteralPart; } Pattern(String pattern); } | Pattern implements ValueMaker { public String firstLiteralPart() { return firstLiteralPart; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public String firstLiteralPart() { return firstLiteralPart; } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testEmptyLastPart() { Assert.assertEquals("", new Pattern("aaa@@table.col1@@").lastLiteralPart()); } | public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } | Pattern implements ValueMaker { public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } } | Pattern implements ValueMaker { public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } Pattern(String pattern); } | Pattern implements ValueMaker { public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); } | Pattern implements ValueMaker { public String lastLiteralPart() { if (literalParts.isEmpty()) { return firstLiteralPart; } return literalParts.get(literalParts.size() - 1); } Pattern(String pattern); String firstLiteralPart(); String lastLiteralPart(); boolean literalPartsMatchRegex(String regex); List<Attribute> attributes(); @Override void describeSelf(NodeSetFilter c); boolean matches(String value); @Override Expression valueExpression(String value); @Override Set<ProjectionSpec> projectionSpecs(); @Override String makeValue(ResultRow row); @Override List<OrderSpec> orderSpecs(boolean ascending); @Override String toString(); @Override boolean equals(Object otherObject); @Override int hashCode(); boolean isEquivalentTo(Pattern p); @Override ValueMaker renameAttributes(ColumnRenamer renames); Iterator<Object> partsIterator(); Expression toExpression(); boolean usesColumnFunctions(); final static String DELIMITER; } |
@Test public void testTrueExpressionsAreSkipped() { Assert.assertEquals(Expression.TRUE, Conjunction.create(Arrays.asList(Expression.TRUE, Expression.TRUE))); Assert.assertEquals(expr1, Conjunction.create( Arrays.asList(Expression.TRUE, expr1, Expression.TRUE))); Assert.assertEquals(conjunction12, Conjunction.create(Arrays.asList(Expression.TRUE, expr1, Expression.TRUE, expr2))); } | public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } |
@Test public void testFalseCausesFailure() { Assert.assertEquals(Expression.FALSE, Conjunction.create(Collections.singleton(Expression.FALSE))); Assert.assertEquals(Expression.FALSE, Conjunction.create(Arrays.asList(expr1, Expression.FALSE))); } | public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } |
@Test public void testRemoveDuplicates() { Assert.assertEquals(expr1, Conjunction.create(Arrays.asList(expr1, expr1))); } | public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } |
@Test public void testTriplePrettyPrinting() { Assert.assertEquals("<http: PrettyPrinter.toString(new Triple(NodeFactory.createURI("http: RDFS.label.asNode(), NodeFactory.createLiteral("Example", null, null)))); } | public static String toString(Node n) { return toString(n, null); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); static final PrefixMapping LIBRARY; } |
@Test public void testFlatten() { Assert.assertEquals(conjunction123, Conjunction.create(Arrays.asList(conjunction12, expr3))); } | public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } | Conjunction extends Expression { public static Expression create(Collection<Expression> expressions) { Set<Expression> elements = new HashSet<>(expressions.size()); for (Expression expression : expressions) { if (expression.isFalse()) { return Expression.FALSE; } if (expression.isTrue()) { continue; } if (expression instanceof Conjunction) { elements.addAll(((Conjunction) expression).expressions); } else { elements.add(expression); } } if (elements.isEmpty()) { return Expression.TRUE; } if (elements.size() == 1) { return elements.iterator().next(); } return new Conjunction(elements); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } |
@Test public void testOrderDoesNotAffectEquality() { Assert.assertEquals(conjunction12, conjunction21); Assert.assertEquals(conjunction12.hashCode(), conjunction21.hashCode()); } | @Override public int hashCode() { return this.expressions.hashCode(); } | Conjunction extends Expression { @Override public int hashCode() { return this.expressions.hashCode(); } } | Conjunction extends Expression { @Override public int hashCode() { return this.expressions.hashCode(); } private Conjunction(Set<Expression> expressions); } | Conjunction extends Expression { @Override public int hashCode() { return this.expressions.hashCode(); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } | Conjunction extends Expression { @Override public int hashCode() { return this.expressions.hashCode(); } private Conjunction(Set<Expression> expressions); static Expression create(Collection<Expression> expressions); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); } |
@Test public void testCreateEmpty() { Assert.assertEquals(new Constant(""), Concatenation.create(Collections.emptyList())); } | public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } private Concatenation(List<Expression> parts); } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } private Concatenation(List<Expression> parts); static Expression create(List<Expression> expressions); @Override Set<Attribute> attributes(); @Override boolean isFalse(); @Override boolean isTrue(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } private Concatenation(List<Expression> parts); static Expression create(List<Expression> expressions); @Override Set<Attribute> attributes(); @Override boolean isFalse(); @Override boolean isTrue(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } |
@Test public void testCreateOnePart() { Expression expr = new AttributeExpr(new Attribute(null, "table", "col")); Assert.assertEquals(expr, Concatenation.create(Collections.singletonList(expr))); } | public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } private Concatenation(List<Expression> parts); } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } private Concatenation(List<Expression> parts); static Expression create(List<Expression> expressions); @Override Set<Attribute> attributes(); @Override boolean isFalse(); @Override boolean isTrue(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } private Concatenation(List<Expression> parts); static Expression create(List<Expression> expressions); @Override Set<Attribute> attributes(); @Override boolean isFalse(); @Override boolean isTrue(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } |
@Test public void testFilterEmptyParts() { Expression empty = new Constant(""); Expression expr1 = new Constant("aaa"); Assert.assertEquals(expr1, Concatenation.create(Arrays.asList( empty, empty, expr1, empty))); } | public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } private Concatenation(List<Expression> parts); } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } private Concatenation(List<Expression> parts); static Expression create(List<Expression> expressions); @Override Set<Attribute> attributes(); @Override boolean isFalse(); @Override boolean isTrue(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | Concatenation extends Expression { public static Expression create(List<Expression> expressions) { List<Expression> nonEmpty = new ArrayList<>(expressions.size()); for (Expression expression : expressions) { if (expression instanceof Constant && "".equals(((Constant) expression).value())) { continue; } nonEmpty.add(expression); } if (nonEmpty.isEmpty()) { return new Constant(""); } if (nonEmpty.size() == 1) { return nonEmpty.get(0); } return new Concatenation(nonEmpty); } private Concatenation(List<Expression> parts); static Expression create(List<Expression> expressions); @Override Set<Attribute> attributes(); @Override boolean isFalse(); @Override boolean isTrue(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } |
@Test public void testCreate() { Expression e = SQLExpression.create("papers.publish = 1"); Assert.assertEquals("SQL(papers.publish = 1)", e.toString()); Assert.assertFalse(e.isTrue()); Assert.assertFalse(e.isFalse()); } | public static Expression create(String sql) { sql = sql.trim(); if ("1".equals(sql)) { return Expression.TRUE; } if ("0".equals(sql)) { return Expression.FALSE; } return new SQLExpression(sql); } | SQLExpression extends Expression { public static Expression create(String sql) { sql = sql.trim(); if ("1".equals(sql)) { return Expression.TRUE; } if ("0".equals(sql)) { return Expression.FALSE; } return new SQLExpression(sql); } } | SQLExpression extends Expression { public static Expression create(String sql) { sql = sql.trim(); if ("1".equals(sql)) { return Expression.TRUE; } if ("0".equals(sql)) { return Expression.FALSE; } return new SQLExpression(sql); } private SQLExpression(String expression); } | SQLExpression extends Expression { public static Expression create(String sql) { sql = sql.trim(); if ("1".equals(sql)) { return Expression.TRUE; } if ("0".equals(sql)) { return Expression.FALSE; } return new SQLExpression(sql); } private SQLExpression(String expression); static Expression create(String sql); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); String getExpression(); } | SQLExpression extends Expression { public static Expression create(String sql) { sql = sql.trim(); if ("1".equals(sql)) { return Expression.TRUE; } if ("0".equals(sql)) { return Expression.FALSE; } return new SQLExpression(sql); } private SQLExpression(String expression); static Expression create(String sql); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); String getExpression(); } |
@Test public void testToString() { Expression e = SQLExpression.create("papers.publish = 1"); Assert.assertEquals("SQL(papers.publish = 1)", e.toString()); } | @Override public String toString() { return "SQL(" + this.expression + ")"; } | SQLExpression extends Expression { @Override public String toString() { return "SQL(" + this.expression + ")"; } } | SQLExpression extends Expression { @Override public String toString() { return "SQL(" + this.expression + ")"; } private SQLExpression(String expression); } | SQLExpression extends Expression { @Override public String toString() { return "SQL(" + this.expression + ")"; } private SQLExpression(String expression); static Expression create(String sql); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); String getExpression(); } | SQLExpression extends Expression { @Override public String toString() { return "SQL(" + this.expression + ")"; } private SQLExpression(String expression); static Expression create(String sql); @Override boolean isTrue(); @Override boolean isFalse(); @Override Set<Attribute> attributes(); @Override Expression renameAttributes(ColumnRenamer columnRenamer); @Override String toSQL(ConnectedDB database, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); String getExpression(); } |
@Test public void testConstantToSQL() { Assert.assertEquals("'foo'", new Constant("foo").toSQL(DummyDB.create(), AliasMap.NO_ALIASES)); } | public abstract String toSQL(ConnectedDB database, AliasMap aliases); | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); } | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); } | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); abstract boolean isTrue(); abstract boolean isFalse(); abstract Set<Attribute> attributes(); abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract String toSQL(ConnectedDB database, AliasMap aliases); Expression and(Expression other); Expression or(Expression other); } | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); abstract boolean isTrue(); abstract boolean isFalse(); abstract Set<Attribute> attributes(); abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract String toSQL(ConnectedDB database, AliasMap aliases); Expression and(Expression other); Expression or(Expression other); static final Expression TRUE; static final Expression FALSE; } |
@Test public void testConstantToSQLWithType() { Attribute attribute = SQL.parseAttribute("table.col1"); ConnectedDB db = DummyDB.create(Collections.singletonMap("table.col1", GenericType.NUMERIC)); Assert.assertEquals("42", new Constant("42", attribute).toSQL(db, AliasMap.NO_ALIASES)); } | public abstract String toSQL(ConnectedDB database, AliasMap aliases); | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); } | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); } | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); abstract boolean isTrue(); abstract boolean isFalse(); abstract Set<Attribute> attributes(); abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract String toSQL(ConnectedDB database, AliasMap aliases); Expression and(Expression other); Expression or(Expression other); } | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); abstract boolean isTrue(); abstract boolean isFalse(); abstract Set<Attribute> attributes(); abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract String toSQL(ConnectedDB database, AliasMap aliases); Expression and(Expression other); Expression or(Expression other); static final Expression TRUE; static final Expression FALSE; } |
@Test public void testConstantToSQLWithTypeAndAlias() { Attribute aliasedAttribute = SQL.parseAttribute("alias.col1"); ConnectedDB db = DummyDB.create(Collections.singletonMap("table.col1", GenericType.NUMERIC)); Assert.assertEquals("42", new Constant("42", aliasedAttribute).toSQL(db, aliases)); } | public abstract String toSQL(ConnectedDB database, AliasMap aliases); | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); } | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); } | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); abstract boolean isTrue(); abstract boolean isFalse(); abstract Set<Attribute> attributes(); abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract String toSQL(ConnectedDB database, AliasMap aliases); Expression and(Expression other); Expression or(Expression other); } | Expression { public abstract String toSQL(ConnectedDB database, AliasMap aliases); abstract boolean isTrue(); abstract boolean isFalse(); abstract Set<Attribute> attributes(); abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract String toSQL(ConnectedDB database, AliasMap aliases); Expression and(Expression other); Expression or(Expression other); static final Expression TRUE; static final Expression FALSE; } |
@Test public void testTriplePrettyPrintingWithNodeANY() { Assert.assertEquals("?ANY ?ANY ?ANY .", PrettyPrinter.toString(Triple.ANY)); } | public static String toString(Node n) { return toString(n, null); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); static final PrefixMapping LIBRARY; } |
@Test public void testConstantTypeAttributeIsRenamed() { Attribute attribute = SQL.parseAttribute("table.col1"); Assert.assertEquals("Constant([email protected])", new Constant("42", attribute).renameAttributes(aliases).toString()); } | public abstract Expression renameAttributes(ColumnRenamer columnRenamer); | Expression { public abstract Expression renameAttributes(ColumnRenamer columnRenamer); } | Expression { public abstract Expression renameAttributes(ColumnRenamer columnRenamer); } | Expression { public abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract boolean isTrue(); abstract boolean isFalse(); abstract Set<Attribute> attributes(); abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract String toSQL(ConnectedDB database, AliasMap aliases); Expression and(Expression other); Expression or(Expression other); } | Expression { public abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract boolean isTrue(); abstract boolean isFalse(); abstract Set<Attribute> attributes(); abstract Expression renameAttributes(ColumnRenamer columnRenamer); abstract String toSQL(ConnectedDB database, AliasMap aliases); Expression and(Expression other); Expression or(Expression other); static final Expression TRUE; static final Expression FALSE; } |
@Test public void testTrueRelationIsTrivial() { Assert.assertTrue(Relation.TRUE.isTrivial()); } | public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } | Relation implements RelationalOperators { public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } } | Relation implements RelationalOperators { public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } } | Relation implements RelationalOperators { public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } static Relation createSimpleRelation(
ConnectedDB database, Attribute[] attributes); abstract ConnectedDB database(); abstract AliasMap aliases(); abstract Set<Join> joinConditions(); abstract Expression condition(); abstract Expression softCondition(); abstract Set<ProjectionSpec> projections(); abstract boolean isUnique(); abstract List<OrderSpec> orderSpecs(); abstract int limit(); abstract int limitInverse(); Set<Attribute> allKnownAttributes(); Set<RelationName> tables(); boolean isTrivial(); static int combineLimits(int limit1, int limit2); } | Relation implements RelationalOperators { public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } static Relation createSimpleRelation(
ConnectedDB database, Attribute[] attributes); abstract ConnectedDB database(); abstract AliasMap aliases(); abstract Set<Join> joinConditions(); abstract Expression condition(); abstract Expression softCondition(); abstract Set<ProjectionSpec> projections(); abstract boolean isUnique(); abstract List<OrderSpec> orderSpecs(); abstract int limit(); abstract int limitInverse(); Set<Attribute> allKnownAttributes(); Set<RelationName> tables(); boolean isTrivial(); static int combineLimits(int limit1, int limit2); final static int NO_LIMIT; static Relation EMPTY; static Relation TRUE; } |
@Test public void testQueryWithSelectColumnsIsNotTrivial() { Assert.assertFalse(rel1.isTrivial()); } | public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } | Relation implements RelationalOperators { public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } } | Relation implements RelationalOperators { public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } } | Relation implements RelationalOperators { public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } static Relation createSimpleRelation(
ConnectedDB database, Attribute[] attributes); abstract ConnectedDB database(); abstract AliasMap aliases(); abstract Set<Join> joinConditions(); abstract Expression condition(); abstract Expression softCondition(); abstract Set<ProjectionSpec> projections(); abstract boolean isUnique(); abstract List<OrderSpec> orderSpecs(); abstract int limit(); abstract int limitInverse(); Set<Attribute> allKnownAttributes(); Set<RelationName> tables(); boolean isTrivial(); static int combineLimits(int limit1, int limit2); } | Relation implements RelationalOperators { public boolean isTrivial() { return projections().isEmpty() && condition().isTrue() && joinConditions().isEmpty(); } static Relation createSimpleRelation(
ConnectedDB database, Attribute[] attributes); abstract ConnectedDB database(); abstract AliasMap aliases(); abstract Set<Join> joinConditions(); abstract Expression condition(); abstract Expression softCondition(); abstract Set<ProjectionSpec> projections(); abstract boolean isUnique(); abstract List<OrderSpec> orderSpecs(); abstract int limit(); abstract int limitInverse(); Set<Attribute> allKnownAttributes(); Set<RelationName> tables(); boolean isTrivial(); static int combineLimits(int limit1, int limit2); final static int NO_LIMIT; static Relation EMPTY; static Relation TRUE; } |
@Test public void testAttributeToString() { Assert.assertEquals("@@foo.bar@@", new Attribute(null, "foo", "bar").toString()); Assert.assertEquals("@@schema.foo.bar@@", new Attribute("schema", "foo", "bar").toString()); } | @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } | Attribute implements ProjectionSpec { @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } } | Attribute implements ProjectionSpec { @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testCompareSameAttribute() { Assert.assertEquals(0, fooCol1.compareTo(fooCol1)); } | @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testCompareSameTableDifferentAttribute() { Assert.assertTrue(fooCol1.compareTo(fooCol2) < 0); Assert.assertTrue(fooCol2.compareTo(fooCol1) > 0); } | @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testCompareSameAttributeDifferentTable() { Assert.assertTrue(barCol1.compareTo(fooCol1) < 0); Assert.assertTrue(fooCol1.compareTo(barCol2) > 0); } | @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testCompareDifferentAttributeDifferentTable() { Assert.assertTrue(barCol2.compareTo(fooCol1) < 0); Assert.assertTrue(fooCol1.compareTo(barCol2) > 0); } | @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testNoSchemaAttributeSmallerThanSchemaAttribute() { Attribute noSchema = new Attribute(null, "z", "col"); Attribute schema = new Attribute("schema", "a", "col"); Assert.assertTrue(noSchema.compareTo(schema) < 0); Assert.assertTrue(schema.compareTo(noSchema) > 0); } | @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testRelationNameToString() { Assert.assertEquals("table", new RelationName(null, "table").toString()); Assert.assertEquals("schema.table", new RelationName("schema", "table").toString()); } | @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } | Attribute implements ProjectionSpec { @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } } | Attribute implements ProjectionSpec { @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public String toString() { return "@@" + this.qualifiedName + "@@"; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testTriplePrettyPrintingWithPrefixMapping() { PrefixMappingImpl prefixes = new PrefixMappingImpl(); prefixes.setNsPrefixes(PrefixMapping.Standard); prefixes.setNsPrefix("ex", "http: Assert.assertEquals("ex:a rdfs:label \"Example\" .", PrettyPrinter.toString(new Triple(NodeFactory.createURI("http: RDFS.label.asNode(), NodeFactory.createLiteral("Example", null, null)), prefixes)); } | public static String toString(Node n) { return toString(n, null); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); static final PrefixMapping LIBRARY; } |
@Test public void testSameRelationNameIsEqual() { Assert.assertEquals(table1, table1b); Assert.assertEquals(table1b, table1); Assert.assertEquals(table1.hashCode(), table1b.hashCode()); } | @Override public int hashCode() { return this.qualifiedName.hashCode(); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testDifferentRelationNamesAreNotEqual() { Assert.assertNotEquals(table1, table2); Assert.assertNotEquals(table2, table1); Assert.assertNotEquals(table1.hashCode(), table2.hashCode()); } | @Override public int hashCode() { return this.qualifiedName.hashCode(); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testSameRelationAndSchemaNameIsEqual() { Assert.assertEquals(table1, table1b); Assert.assertEquals(table1b, table1); Assert.assertEquals(table1.hashCode(), table1b.hashCode()); } | @Override public int hashCode() { return this.qualifiedName.hashCode(); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testDifferentSchemaNamesAreNotEqual() { Assert.assertNotEquals(xTable1, yTable1); Assert.assertNotEquals(yTable1, xTable1); Assert.assertNotEquals(xTable1.hashCode(), yTable1.hashCode()); } | @Override public int hashCode() { return this.qualifiedName.hashCode(); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testSchemaAndNoSchemaAreNotEqual() { Assert.assertNotEquals(xTable1, table1); Assert.assertNotEquals(table1, xTable1); Assert.assertNotEquals(table1.hashCode(), xTable1.hashCode()); } | @Override public int hashCode() { return this.qualifiedName.hashCode(); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int hashCode() { return this.qualifiedName.hashCode(); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testCompareRelationNamesDifferentSchema() { Assert.assertTrue(xTable1.compareTo(yTable1) < 0); Assert.assertTrue(yTable1.compareTo(xTable1) > 0); } | @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testCompareRelationNamesSameSchema() { Assert.assertTrue(table1.compareTo(table2) < 0); Assert.assertTrue(table2.compareTo(table1) > 0); Assert.assertTrue(xTable1.compareTo(xTable2) < 0); Assert.assertTrue(xTable2.compareTo(xTable1) > 0); } | @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testNoSchemaRelationNameSmallerSchemaRelationName() { RelationName noSchema = new RelationName(null, "z"); RelationName schema = new RelationName("schema", "a"); Assert.assertTrue(noSchema.compareTo(schema) < 0); Assert.assertTrue(schema.compareTo(noSchema) > 0); } | @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testCompareSameRelationName() { Assert.assertEquals(0, table1.compareTo(table1)); Assert.assertEquals(0, xTable1.compareTo(xTable1)); } | @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { @Override public int compareTo(ProjectionSpec other) { if (!(other instanceof Attribute)) { return -1; } Attribute otherAttribute = (Attribute) other; int i = this.relationName.compareTo(otherAttribute.relationName); if (i != 0) { return i; } return this.attributeName.compareTo(otherAttribute.attributeName); } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testRelationNameWithPrefixNoSchema() { Assert.assertEquals("T42_table1", table1.withPrefix(42).qualifiedName()); } | public String qualifiedName() { return this.qualifiedName; } | Attribute implements ProjectionSpec { public String qualifiedName() { return this.qualifiedName; } } | Attribute implements ProjectionSpec { public String qualifiedName() { return this.qualifiedName; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { public String qualifiedName() { return this.qualifiedName; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { public String qualifiedName() { return this.qualifiedName; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testResourcePrettyPrinting() { Model m = ModelFactory.createDefaultModel(); Assert.assertEquals("\"foo\"", PrettyPrinter.toString(m.createLiteral("foo"))); Assert.assertEquals("<http: } | public static String toString(Node n) { return toString(n, null); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); static final PrefixMapping LIBRARY; } |
@Test public void testRelationNameWithPrefixWithSchema() { Assert.assertEquals("T42_x_table1", xTable1.withPrefix(42).qualifiedName()); } | public String qualifiedName() { return this.qualifiedName; } | Attribute implements ProjectionSpec { public String qualifiedName() { return this.qualifiedName; } } | Attribute implements ProjectionSpec { public String qualifiedName() { return this.qualifiedName; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); } | Attribute implements ProjectionSpec { public String qualifiedName() { return this.qualifiedName; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } | Attribute implements ProjectionSpec { public String qualifiedName() { return this.qualifiedName; } Attribute(String schemaName, String tableName, String attributeName); Attribute(RelationName relationName, String attributeName); String qualifiedName(); @Override String toSQL(ConnectedDB database, AliasMap aliases); String attributeName(); String tableName(); RelationName relationName(); String schemaName(); @Override Set<Attribute> requiredAttributes(); Expression selectValue(String value); @Override ProjectionSpec renameAttributes(ColumnRenamer renamer); @Override Expression toExpression(); @Override Expression notNullExpression(ConnectedDB db, AliasMap aliases); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); @Override int compareTo(ProjectionSpec other); } |
@Test public void testApplyToUnmappedColumnReturnsSameColumn() { Assert.assertEquals(col3, this.col1ToCol2.applyTo(col3)); } | public abstract Attribute applyTo(Attribute original); | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); final static ColumnRenamer NULL; } |
@Test public void testApplyToMappedColumnReturnsNewName() { Assert.assertEquals(col2, this.col1ToCol2.applyTo(col1)); } | public abstract Attribute applyTo(Attribute original); | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); final static ColumnRenamer NULL; } |
@Test public void testApplyToNewNameReturnsNewName() { Assert.assertEquals(col2, this.col1ToCol2.applyTo(col2)); } | public abstract Attribute applyTo(Attribute original); | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); final static ColumnRenamer NULL; } |
@Test public void testApplyToExpressionReplacesMappedColumns() { Expression e = SQLExpression.create("foo.col1=foo.col3"); Assert.assertEquals(SQLExpression.create("foo.col2=foo.col3"), this.col1ToCol2.applyTo(e)); } | public abstract Attribute applyTo(Attribute original); | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); final static ColumnRenamer NULL; } |
@Test public void testApplyToAliasMapReturnsOriginal() { AliasMap aliases = new AliasMap(Collections.singleton(new Alias( new RelationName(null, "foo"), new RelationName(null, "bar")))); Assert.assertEquals(aliases, this.col1ToCol2.applyTo(aliases)); } | public abstract Attribute applyTo(Attribute original); | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); final static ColumnRenamer NULL; } |
@Test public void testRenameWithSchema() { Attribute foo_c1 = new Attribute("schema", "foo", "col1"); Attribute bar_c2 = new Attribute("schema", "bar", "col2"); ColumnRenamer renamer = new ColumnRenamerMap(Collections.singletonMap(foo_c1, bar_c2)); Assert.assertEquals(bar_c2, renamer.applyTo(foo_c1)); Assert.assertEquals(col1, renamer.applyTo(col1)); } | public abstract Attribute applyTo(Attribute original); | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); } | ColumnRenamer { public abstract Attribute applyTo(Attribute original); abstract Attribute applyTo(Attribute original); Join applyTo(Join original); Expression applyTo(Expression original); Set<Join> applyToJoinSet(Set<Join> joins); ProjectionSpec applyTo(ProjectionSpec original); Set<ProjectionSpec> applyToProjectionSet(Set<ProjectionSpec> projections); List<OrderSpec> applyTo(List<OrderSpec> orderSpecs); abstract AliasMap applyTo(AliasMap aliases); final static ColumnRenamer NULL; } |
@Test public void testApplyToColumn() { Assert.assertEquals(baz_col1, this.fooAsBarMap.applyTo(baz_col1)); Assert.assertEquals(bar_col1, this.fooAsBarMap.applyTo(foo_col1)); Assert.assertEquals(bar_col1, this.fooAsBarMap.applyTo(bar_col1)); } | public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testOriginalOfColumn() { Assert.assertEquals(baz_col1, this.fooAsBarMap.originalOf(baz_col1)); Assert.assertEquals(foo_col1, this.fooAsBarMap.originalOf(foo_col1)); Assert.assertEquals(foo_col1, this.fooAsBarMap.originalOf(bar_col1)); } | public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testApplyToSQLExpression() { Assert.assertEquals(SQLExpression.create("bar.col1 = 1"), fooAsBarMap.applyTo(SQLExpression.create("foo.col1 = 1"))); } | public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testUsePrefixMappingWhenPrintingURIResources() { Model m = ModelFactory.createDefaultModel(); m.setNsPrefix("ex", "http: Assert.assertEquals("ex:foo", PrettyPrinter.toString(m.createResource("http: } | public static String toString(Node n) { return toString(n, null); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); static final PrefixMapping LIBRARY; } |
@Test public void testEqualMapsHaveSameHashCode() { AliasMap m1 = new AliasMap(new ArrayList<>()); AliasMap m2 = new AliasMap(new ArrayList<>()); Assert.assertEquals(m1.hashCode(), m2.hashCode()); } | @Override public int hashCode() { return this.byAlias.hashCode(); } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testAliasEquals() { Alias fooAsBar2 = new Alias(foo, bar); Assert.assertEquals(fooAsBar, fooAsBar2); Assert.assertEquals(fooAsBar2, fooAsBar); Assert.assertEquals(fooAsBar.hashCode(), fooAsBar2.hashCode()); } | @Override public int hashCode() { return this.byAlias.hashCode(); } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testAliasNotEquals() { Assert.assertNotEquals(fooAsBar, fooAsBaz); Assert.assertNotEquals(fooAsBaz, fooAsBar); Assert.assertNotEquals(fooAsBar, bazAsBar); Assert.assertNotEquals(bazAsBar, fooAsBar); Assert.assertNotEquals(fooAsBar.hashCode(), fooAsBaz.hashCode()); Assert.assertNotEquals(fooAsBar.hashCode(), bazAsBar.hashCode()); } | @Override public int hashCode() { return this.byAlias.hashCode(); } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { @Override public int hashCode() { return this.byAlias.hashCode(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testAliasToString() { Assert.assertEquals("foo AS bar", fooAsBar.toString()); } | @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testApplyToAliasEmpty() { Assert.assertEquals(fooAsBar, AliasMap.NO_ALIASES.applyTo(fooAsBar)); } | public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testApplyToAlias() { Assert.assertEquals(new Alias(baz, bar), fooAsBarMap.applyTo(new Alias(baz, foo))); } | public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { public RelationName applyTo(RelationName original) { if (!hasAlias(original)) { return original; } Alias alias = this.byOriginal.get(original); return alias.alias(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testOriginalOfAliasEmpty() { Assert.assertEquals(fooAsBar, AliasMap.NO_ALIASES.originalOf(fooAsBar)); } | public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testOriginalOfAlias() { Assert.assertEquals(fooAsBaz, fooAsBarMap.originalOf(new Alias(bar, baz))); } | public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { public RelationName originalOf(RelationName name) { if (!isAlias(name)) { return name; } Alias alias = this.byAlias.get(name); return alias.original(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testToStringEmpty() { Assert.assertEquals("AliasMap()", AliasMap.NO_ALIASES.toString()); } | @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testToStringOneAlias() { Assert.assertEquals("AliasMap(foo AS bar)", fooAsBarMap.toString()); } | @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } AliasMap(Collection<Alias> aliases); } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); } | AliasMap extends ColumnRenamer { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append("AliasMap("); List<RelationName> tables = new ArrayList<>(this.byAlias.keySet()); Collections.sort(tables); Iterator<RelationName> it = tables.iterator(); while (it.hasNext()) { result.append(this.byAlias.get(it.next())); if (it.hasNext()) { result.append(", "); } } result.append(")"); return result.toString(); } AliasMap(Collection<Alias> aliases); static AliasMap create1(RelationName original, RelationName alias); boolean isAlias(RelationName name); boolean hasAlias(RelationName original); RelationName applyTo(RelationName original); RelationName originalOf(RelationName name); Attribute applyTo(Attribute attribute); Attribute originalOf(Attribute attribute); Alias applyTo(Alias alias); Alias originalOf(Alias alias); @Override Join applyTo(Join join); @Override AliasMap applyTo(AliasMap other); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); static final AliasMap NO_ALIASES; } |
@Test public void testD2RQTermsHaveD2RQPrefix() { Assert.assertEquals("d2rq:ClassMap", PrettyPrinter.toString(D2RQ.ClassMap)); } | public static String toString(Node n) { return toString(n, null); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); } | PrettyPrinter { public static String toString(Node n) { return toString(n, null); } static String toString(Node n); static String toString(Node n, PrefixMapping prefixes); static String toString(Statement s); static String toString(Triple t); static String toString(Triple t, PrefixMapping prefixes); static String toString(RDFDatatype datatype); static String toString(RDFNode n); static String toString(Collection<? extends RDFNode> res); static final PrefixMapping LIBRARY; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.