Skip to content
This repository has been archived by the owner on Sep 19, 2023. It is now read-only.

Commit

Permalink
Use ordering logic in min/max
Browse files Browse the repository at this point in the history 
Closes comunica/comunica#1212
  • Loading branch information
@jitsedesmet
jitsedesmet authored Aug 8, 2023
1 parent 6c22f37 commit 3bf0950
Show file tree
Hide file tree
Showing 8 changed files with 120 additions and 82 deletions.
9 changes: 0 additions & 9 deletions lib/aggregators/Aggregator.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,15 +35,6 @@ export abstract class AggregatorComponent {
}
return <E.NumericLiteral> this.termTransformer.transformLiteral(term);
}

protected extractValue(term: RDF.Term): { value: any; type: string } {
if (term.termType !== 'Literal') {
throw new Error(`Term with value ${term.value} has type ${term.termType} and is not a literal`);
}

const transformedLit = this.termTransformer.transformLiteral(term);
return { type: transformedLit.dataType, value: transformedLit.typedValue };
}
}

/**
Expand Down
24 changes: 9 additions & 15 deletions lib/aggregators/Max.ts
View file
Original file line number Diff line number Diff line change
@@ -1,31 +1,25 @@
import type * as RDF from '@rdfjs/types';
import { orderTypes } from '../util/Ordering';
import { AggregatorComponent } from './Aggregator';

interface IExtremeState {
extremeValue: number; term: RDF.Term;
}
export class Max extends AggregatorComponent {
private state: IExtremeState | undefined = undefined;
private state: RDF.Term | undefined = undefined;

public put(term: RDF.Term): void {
if (term.termType !== 'Literal') {
throw new Error(`Term with value ${term.value} has type ${term.termType} and is not a literal`);
}
if (this.state === undefined) {
const { value } = this.extractValue(term);
this.state = { extremeValue: value, term };
} else {
const extracted = this.extractValue(term);
if (extracted.value > this.state.extremeValue) {
this.state = {
extremeValue: extracted.value,
term,
};
}
this.state = term;
} else if (orderTypes(this.state, term) === -1) {
this.state = term;
}
}

public result(): RDF.Term | undefined {
if (this.state === undefined) {
return Max.emptyValue();
}
return this.state.term;
return this.state;
}
}
24 changes: 9 additions & 15 deletions lib/aggregators/Min.ts
View file
Original file line number Diff line number Diff line change
@@ -1,31 +1,25 @@
import type * as RDF from '@rdfjs/types';
import { orderTypes } from '../util/Ordering';
import { AggregatorComponent } from './Aggregator';

interface IExtremeState {
extremeValue: number; term: RDF.Term;
}
export class Min extends AggregatorComponent {
private state: IExtremeState | undefined = undefined;
private state: RDF.Term | undefined = undefined;

public put(term: RDF.Term): void {
if (term.termType !== 'Literal') {
throw new Error(`Term with value ${term.value} has type ${term.termType} and is not a literal`);
}
if (this.state === undefined) {
const { value } = this.extractValue(term);
this.state = { extremeValue: value, term };
} else {
const extracted = this.extractValue(term);
if (extracted.value < this.state.extremeValue) {
this.state = {
extremeValue: extracted.value,
term,
};
}
this.state = term;
} else if (orderTypes(this.state, term) === 1) {
this.state = term;
}
}

public result(): RDF.Term | undefined {
if (this.state === undefined) {
return Min.emptyValue();
}
return this.state.term;
return this.state;
}
}
71 changes: 29 additions & 42 deletions lib/util/Ordering.ts
View file
Original file line number Diff line number Diff line change
@@ -1,16 +1,14 @@
import type * as RDF from '@rdfjs/types';
import * as LRUCache from 'lru-cache';
import type { LangStringLiteral } from '../expressions';
import { isNonLexicalLiteral } from '../expressions';
import type * as E from '../expressions';
import { regularFunctions } from '../functions';
import { TermTransformer } from '../transformers/TermTransformer';
import { TypeAlias, TypeURL } from './Consts';
import type { ITimeZoneRepresentation } from './DateTimeHelpers';
import { toUTCDate } from './DateTimeHelpers';
import * as C from './Consts';
import * as Err from './Errors';
import type { ISuperTypeProvider, SuperTypeCallback, TypeCache, GeneralSuperTypeDict } from './TypeHandling';
import { getSuperTypeDict } from './TypeHandling';
import type { SuperTypeCallback, TypeCache } from './TypeHandling';

// Determine the relative numerical order of the two given terms.
// In accordance with https://www.w3.org/TR/sparql11-query/#modOrderBy
/**
* @param enableExtendedXSDTypes System will behave like when this was true. @deprecated
*/
Expand Down Expand Up @@ -79,49 +77,38 @@ export function orderTypes(termA: RDF.Term | undefined, termB: RDF.Term | undefi

function orderLiteralTypes(litA: RDF.Literal, litB: RDF.Literal,
typeDiscoveryCallback?: SuperTypeCallback, typeCache?: TypeCache): -1 | 0 | 1 {
const defaultTimezone: ITimeZoneRepresentation = { zoneHours: 0, zoneMinutes: 0 };

const openWorldType: ISuperTypeProvider = {
discoverer: typeDiscoveryCallback || (() => 'term'),
cache: typeCache || new LRUCache(),
const isGreater = regularFunctions[C.RegularOperator.GT];
const isEqual = regularFunctions[C.RegularOperator.EQUAL];
const context = {
now: new Date(),
functionArgumentsCache: {},
superTypeProvider: {
discoverer: typeDiscoveryCallback || (() => 'term'),
cache: typeCache || new LRUCache(),
},
defaultTimeZone: { zoneHours: 0, zoneMinutes: 0 },
};
const termTransformer = new TermTransformer(openWorldType);

const termTransformer = new TermTransformer(context.superTypeProvider);
const myLitA = termTransformer.transformLiteral(litA);
const myLitB = termTransformer.transformLiteral(litB);
const typeA = myLitA.dataType;
const typeB = myLitB.dataType;

const superTypeDictA: GeneralSuperTypeDict = getSuperTypeDict(typeA, openWorldType);
const superTypeDictB: GeneralSuperTypeDict = getSuperTypeDict(typeB, openWorldType);

// Special handling of specific datatypes
if (!isNonLexicalLiteral(myLitA) && !isNonLexicalLiteral(myLitB)) {
if (TypeURL.XSD_BOOLEAN in superTypeDictA && TypeURL.XSD_BOOLEAN in superTypeDictB ||
TypeAlias.SPARQL_NUMERIC in superTypeDictA && TypeAlias.SPARQL_NUMERIC in superTypeDictB ||
TypeURL.XSD_STRING in superTypeDictA && TypeURL.XSD_STRING in superTypeDictB) {
return comparePrimitives(myLitA.typedValue, myLitB.typedValue);
try {
if ((<E.BooleanLiteral> isEqual.apply([ myLitA, myLitB ], context)).typedValue) {
return 0;
}
if (TypeURL.XSD_DATE_TIME in superTypeDictA && TypeURL.XSD_DATE_TIME in superTypeDictB) {
return comparePrimitives(
toUTCDate(myLitA.typedValue, defaultTimezone).getTime(),
toUTCDate(myLitB.typedValue, defaultTimezone).getTime(),
);
if ((<E.BooleanLiteral> isGreater.apply([ myLitA, myLitB ], context)).typedValue) {
return 1;
}
if (TypeURL.RDF_LANG_STRING in superTypeDictA && TypeURL.RDF_LANG_STRING in superTypeDictB) {
const compareType = comparePrimitives(myLitA.typedValue, myLitB.typedValue);
if (compareType !== 0) {
return compareType;
}
return comparePrimitives((<LangStringLiteral>myLitA).language, (<LangStringLiteral>myLitB).language);
return -1;
} catch {
// Fallback to string-based comparison
const compareType = comparePrimitives(myLitA.dataType, myLitB.dataType);
if (compareType !== 0) {
return compareType;
}
return comparePrimitives(myLitA.str(), myLitB.str());
}

// Fallback to string-based comparison
const compareType = comparePrimitives(typeA, typeB);
if (compareType !== 0) {
return compareType;
}
return comparePrimitives(myLitA.str(), myLitB.str());
}

function comparePrimitives(valueA: any, valueB: any): -1 | 0 | 1 {
Expand Down
69 changes: 69 additions & 0 deletions test/integration/evaluators/AggregateEvaluator.test.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -115,6 +115,10 @@ function string(value: string): RDF.Term {
return DF.literal(value, DF.namedNode('http://www.w3.org/2001/XMLSchema#string'));
}

function date(value: string): RDF.Term {
return DF.literal(value, DF.namedNode('http://www.w3.org/2001/XMLSchema#date'));
}

describe('an aggregate evaluator should be able to', () => {
describe('count', () => {
let baseTestCaseArgs: IBaseTestCaseArgs;
Expand Down Expand Up @@ -386,6 +390,45 @@ describe('an aggregate evaluator should be able to', () => {
expect(await result).toEqual(string('1'));
});

it('a list of date bindings', async() => {
const result = testCase({
...baseTestCaseArgs,
input: [
BF.bindings([[ DF.variable('x'), date('2010-06-21Z') ]]),
BF.bindings([[ DF.variable('x'), date('2010-06-21-08:00') ]]),
BF.bindings([[ DF.variable('x'), date('2001-07-23') ]]),
BF.bindings([[ DF.variable('x'), date('2010-06-21+09:00') ]]),
],
});
expect(await result).toEqual(date('2001-07-23'));
});

it('passing a non-literal to max should not be accepted', async() => {
const result = testCase({
...baseTestCaseArgs,
input: [
BF.bindings([[ DF.variable('x'), nonLiteral() ]]),
BF.bindings([[ DF.variable('x'), int('2') ]]),
BF.bindings([[ DF.variable('x'), int('3') ]]),
],
evalTogether: true,
});
expect(await result).toEqual(undefined);
});

it('passing a non-literal to max should not be accepted even in non-first place', async() => {
const result = testCase({
...baseTestCaseArgs,
input: [
BF.bindings([[ DF.variable('x'), int('2') ]]),
BF.bindings([[ DF.variable('x'), nonLiteral() ]]),
BF.bindings([[ DF.variable('x'), int('3') ]]),
],
evalTogether: true,
});
expect(await result).toEqual(undefined);
});

it('with respect to empty input', async() => {
const result = testCase({
...baseTestCaseArgs,
Expand Down Expand Up @@ -426,6 +469,19 @@ describe('an aggregate evaluator should be able to', () => {
expect(await result).toEqual(string('3'));
});

it('a list of date bindings', async() => {
const result = testCase({
...baseTestCaseArgs,
input: [
BF.bindings([[ DF.variable('x'), date('2010-06-21Z') ]]),
BF.bindings([[ DF.variable('x'), date('2010-06-21-08:00') ]]),
BF.bindings([[ DF.variable('x'), date('2001-07-23') ]]),
BF.bindings([[ DF.variable('x'), date('2010-06-21+09:00') ]]),
],
});
expect(await result).toEqual(date('2010-06-21-08:00'));
});

it('with respect to empty input', async() => {
const result = testCase({
...baseTestCaseArgs,
Expand Down Expand Up @@ -621,6 +677,19 @@ describe('an aggregate evaluator should be able to', () => {
expect(await result).toEqual(undefined);
});

it('passing a non-literal to max should not be accepted even in non-first place', async() => {
const result = testCase({
expr: makeAggregate('max'),
input: [
BF.bindings([[ DF.variable('x'), int('2') ]]),
BF.bindings([[ DF.variable('x'), nonLiteral() ]]),
BF.bindings([[ DF.variable('x'), int('3') ]]),
],
evalTogether: true,
});
expect(await result).toEqual(undefined);
});

it('passing a non-literal to sum should not be accepted', async() => {
const testCaseArg = {
expr: makeAggregate('sum'),
Expand Down
1 change: 1 addition & 0 deletions test/integration/functions/op.equality.test.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,6 +35,7 @@ describe('evaluation of \'=\'', () => {
3f INF = false
INF NaN = false
NaN NaN = false
NaNd NaNd = false
NaN 3f = false
3f NaN = false
`,
Expand Down
3 changes: 2 additions & 1 deletion test/integration/util/Ordering.test.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -103,7 +103,8 @@ describe('terms order', () => {
it('dateTime type comparison', () => {
genericOrderTestLower(dateTime('2000-01-01T00:00:00Z'), dateTime('2001-01-01T00:00:00Z'));
});
it('langString type comparison', () => {
it.skip('langString type comparison', () => {
// Skip for now, spec does not say anything about order of langStrings
genericOrderTestLower(DF.literal('a', 'de'), DF.literal('a', 'en'));
genericOrderTestLower(DF.literal('a', 'en'), DF.literal('b', 'en'));
});
Expand Down
1 change: 1 addition & 0 deletions test/util/Aliases.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -176,6 +176,7 @@ export const numeric: AliasMap = {
'-12f': '"-12"^^xsd:float',
NaN: '"NaN"^^xsd:float',
INF: '"INF"^^xsd:float',
NaNd: '"NaN"^^xsd:double',
'-INF': '"-INF"^^xsd:float',

'0d': '"0"^^xsd:decimal',
Expand Down

0 comments on commit 3bf0950

Please sign in to comment.