1505

pending completion

Build # 1505

Build Type

Pull #380

travis-ci-com

Committed by

web-flow

Commit Message

Merge 2e7345d8d into 73931d76a

Pull Request Pull Request #380: Bring back join

Run Details

4605 of 6444 branches covered (71.46%)

Branch coverage included in aggregate %.

169 of 179 new or added lines in 9 files covered. (94.41%)

67 existing lines in 1 file now uncovered.

10516 of 12980 relevant lines covered (81.02%)

48288.27 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.4

/lib/compiler/ops.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2018-2020 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>

import assert from 'assert';

import * as Ast from '../ast';
import Type from "../type";

import ReduceOp from './reduceop';

// Low-level ThingTalk operations
// Each ThingTalk AST node can be implemented in terms of these low-level ops
// Each of these ops can be compiled into JS code individually

// PointWiseOp : operates on each produced tuple
export class PointWiseOp {
}

export namespace PointWiseOp {
export class Projection extends PointWiseOp {
    constructor(public args : Set<string>) {
        super();
    }

    toString() {
        return `PointWiseOp.Projection(${this.args})`;
    }
}

export class Compute extends PointWiseOp {
    constructor(public expression : Ast.Value,
                public alias : string) {
        super();
    }

    toString() {
        return `PointWiseOp.Compute(${this.expression} as ${this.alias})`;
    }
}

export class BooleanCompute extends PointWiseOp {
    constructor(public booleanExpression : Ast.BooleanExpression) {
        super();
    }

    toString() {
        return `PointWiseOp.BooleanCompute(${this.booleanExpression})`;
    }
}
}

type SortHint = [string, 'asc'|'desc'];
export class QueryInvocationHints {
    projection : Set<string>;
    filter : Ast.BooleanExpression;
    sort : SortHint|undefined;
    limit : number|undefined;

    constructor(projection : Set<string>,
                filter = Ast.BooleanExpression.True,
                sort ?: SortHint,
                limit ?: number) {
        assert(filter instanceof Ast.BooleanExpression);
        assert(sort === undefined || Array.isArray(sort));
        assert(projection instanceof Set);
        assert(limit === undefined || typeof limit === 'number');

        this.filter = filter;
        this.sort = sort;
        this.projection = projection;
        this.limit = limit;
    }

    clone() : QueryInvocationHints {
        return new QueryInvocationHints(new Set(this.projection), this.filter, this.sort, this.limit);
    }
}

/**
 * A low-level operation on streams
 */
export abstract class StreamOp {
    abstract ast : Ast.Expression|null;
}

export namespace StreamOp {
export class Now extends StreamOp {
    constructor(public table : TableOp,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.Now(${this.table})`;
    }
}

export class InvokeVarRef extends StreamOp {
    constructor(public name : string,
                public in_params : Ast.InputParam[],
                public ast : Ast.Expression,
                public hints : QueryInvocationHints) {
        super();
    }

    toString() {
        return `StreamOp.InvokeVarRef(${this.name}, ${this.in_params.map((ip) => ip.prettyprint()).join(', ')})`;
    }
}

export class InvokeSubscribe extends StreamOp {
    constructor(public invocation : Ast.Invocation,
                public ast : Ast.Expression,
                public hints : QueryInvocationHints) {
        super();
    }

    toString() {
        return `StreamOp.InvokeSubscribe(${this.invocation.prettyprint()})`;
    }
}

export class Timer extends StreamOp {
    constructor(public base : Ast.Value|undefined,
                public interval : Ast.Value,
                public frequency : Ast.Value|undefined,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.Timer(${this.base}, ${this.interval}, ${this.frequency})`;
    }
}

export class AtTimer extends StreamOp {
    constructor(public time : Ast.Value,
                public expiration_date : Ast.Value|undefined,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.AtTimer(${this.time}, ${this.expiration_date})`;
    }
}

export class OnTimer extends StreamOp {
    constructor(public date : Ast.Value,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.OnTimer(${this.date})`;
    }
}

export class Filter extends StreamOp {
    constructor(public stream : StreamOp,
                public filter : BooleanExpressionOp,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.Filter(${this.stream}, ${this.filter})`;
    }
}

export class Map extends StreamOp {
    constructor(public stream : StreamOp,
                public op : PointWiseOp,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.Map(${this.stream}, ${this.op})`;
    }
}

export class EdgeNew extends StreamOp {
    constructor(public stream : StreamOp,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.EdgeNew(${this.stream})`;
    }
}

export class EdgeFilter extends StreamOp {
    constructor(public stream : StreamOp,
                public filter : BooleanExpressionOp,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.EdgeFilter(${this.stream}, ${this.filter})`;
    }
}

export class Union extends StreamOp {
    constructor(public lhs : StreamOp,
                public rhs : StreamOp,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.Union(${this.lhs}, ${this.rhs})`;
    }
}

/**
  When the stream fires, get the whole table (ignore the stream).
  This is used to implement certain "monitor(table)" where the
  table needs to be recomputed on subscribe.
 */
export class InvokeTable extends StreamOp {
    constructor(public stream : StreamOp,
                public table : TableOp,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.InvokeTable(${this.stream}, ${this.table})`;
    }
}

/**
 * When the stream fires, get the whole table and join it.
 */
export class Join extends StreamOp {
    constructor(public stream : StreamOp,
                public table : TableOp,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `StreamOp.Join(${this.stream}, ${this.table})`;
    }
}
}

type UnaryStreamOp = StreamOp.Filter | StreamOp.Map | StreamOp.EdgeFilter | StreamOp.EdgeNew;
export function isUnaryStreamOp(op : StreamOp) : op is UnaryStreamOp {
    return op instanceof StreamOp.Filter ||
        op instanceof StreamOp.Map ||
        op instanceof StreamOp.EdgeFilter ||
        op instanceof StreamOp.EdgeNew;
}

/**
 * A low-level operation on an in-memory table.
 */
export abstract class TableOp {
    handle_thingtalk = false;
    abstract device : Ast.DeviceSelector|null;
    abstract ast : Ast.Expression;
}

export namespace TableOp {
export class InvokeVarRef extends TableOp {
    device = null;

    constructor(public name : string,
                public in_params : Ast.InputParam[],
                public ast : Ast.Expression,
                public hints : QueryInvocationHints) {
        super();
    }

    toString() {
        return `TableOp.InvokeVarRef(${this.name}, ${this.in_params.map((ip) => ip.prettyprint())})`;
    }
}

export class InvokeGet extends TableOp {
    constructor(public invocation : Ast.Invocation,
                public device : Ast.DeviceSelector|null,
                public handle_thingtalk : boolean,
                public ast : Ast.Expression,
                public hints : QueryInvocationHints) {
        super();
    }

    toString() {
        return `TableOp.InvokeGet(${this.invocation.prettyprint()})`;
    }
}

export class Filter extends TableOp {
    constructor(public table : TableOp,
                public filter : BooleanExpressionOp,
                public device : Ast.DeviceSelector|null,
                public handle_thingtalk : boolean,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `TableOp.Filter(${this.table}, ${this.filter})`;
    }
}

export class Map extends TableOp {
    constructor(public table : TableOp,
                public op : PointWiseOp,
                public device : Ast.DeviceSelector|null,
                public handle_thingtalk : boolean,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `TableOp.Map(${this.table}, ${this.op})`;
    }
}

export class Reduce extends TableOp {
    constructor(public table : TableOp,
                public op : ReduceOp<unknown>,
                public device : Ast.DeviceSelector|null,
                public handle_thingtalk : boolean,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `TableOp.Reduce(${this.table}, ${this.op})`;
    }
}

export class Join extends TableOp {
    constructor(public lhs : TableOp,
                public rhs : TableOp,
                public condition : BooleanExpressionOp|null,
                public device : Ast.DeviceSelector|null,
                public handle_thingtalk : boolean,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `TableOp.Join(${this.lhs}, ${this.rhs}, ${this.condition})`;
    }
}

export class CrossJoin extends TableOp {
    constructor(public lhs : TableOp,
                public rhs : TableOp,
                public device : Ast.DeviceSelector|null,
                public handle_thingtalk : boolean,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `TableOp.CrossJoin(${this.lhs}, ${this.rhs})`;
    }
}

export class NestedLoopJoin extends TableOp {
    constructor(public lhs : TableOp,
                public rhs : TableOp,
                public device : Ast.DeviceSelector|null,
                public handle_thingtalk : boolean,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `TableOp.NestedLoopJoin(${this.lhs}, ${this.rhs})`;
    }
}
}

type UnaryTableOp = TableOp.Filter | TableOp.Map | TableOp.Reduce;
export function isUnaryTableOp(op : TableOp) : op is UnaryTableOp {
    return op instanceof TableOp.Filter ||
        op instanceof TableOp.Map ||
        op instanceof TableOp.Reduce;
}

export abstract class ActionOp {

}

export namespace ActionOp {
export class InvokeDo extends ActionOp {
    constructor(public invocation : Ast.Invocation,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `ActionOp.InvokeDo(${this.invocation.prettyprint()})`;
    }
}

export class InvokeVarRef extends ActionOp {
    constructor(public name : string,
                public in_params : Ast.InputParam[],
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `ActionOp.InvokeVarRef(${this.name}, ${this.in_params.map((ip) => ip.prettyprint())})`;
    }
}
}

/**
 * The overall structure of the rule.
 * This reflects the overall "when => get* => do" structure of ThingTalk
 * which is what it optimizes for.
 */
export class RuleOp {
    constructor(public stream : StreamOp|null,
                public action : ActionOp|null,
                public ast : Ast.ExpressionStatement|Ast.ReturnStatement) {
    }

    toString() {
        return `RuleOp(${this.stream}, ${this.action})`;
    }
}

export abstract class BooleanExpressionOp {
    static True : ConstantBooleanExpressionOp;
    static False : ConstantBooleanExpressionOp;

    public ast : Ast.BooleanExpression;

    protected constructor(ast : Ast.BooleanExpression) {
        this.ast = ast;
    }
}

class ConstantBooleanExpressionOp extends BooleanExpressionOp {
    constructor(public readonly value : boolean) {
        super(value ? Ast.BooleanExpression.True : Ast.BooleanExpression.False);
    }

    toString() {
        return `BooleanExpressionOp.Constant(${this.value})`;
    }
}
BooleanExpressionOp.True = new ConstantBooleanExpressionOp(true);
BooleanExpressionOp.False = new ConstantBooleanExpressionOp(false);

export namespace BooleanExpressionOp {
export class And extends BooleanExpressionOp {
    constructor(ast : Ast.AndBooleanExpression,
                public operands : BooleanExpressionOp[]) {
        super(ast);
    }

    toString() {
        return `BooleanExpressionOp.And(${this.operands.join(', ')})`;
    }
}

export class Or extends BooleanExpressionOp {
    constructor(ast : Ast.OrBooleanExpression,
                public operands : BooleanExpressionOp[]) {
        super(ast);
    }

    toString() {
        return `BooleanExpressionOp.Or(${this.operands.join(', ')})`;
    }
}

export class Not extends BooleanExpressionOp {
    constructor(ast : Ast.NotBooleanExpression,
                public expr : BooleanExpressionOp) {
        super(ast);
    }

    toString() {
        return `BooleanExpressionOp.Not(${this.expr})`;
    }
}

export class Atom extends BooleanExpressionOp {
    constructor(ast : Ast.AtomBooleanExpression|Ast.ComputeBooleanExpression,
                public lhs : Ast.Value,
                public operator : string,
                public rhs : Ast.Value,
                public overload : Type[]|null){
        super(ast);
    }

    toString() {
        return `BooleanExpressionOp.Atom(${this.lhs}, ${this.operator}, ${this.rhs})`;
    }
}

export class ExistentialSubquery extends BooleanExpressionOp {
    constructor(ast : Ast.ExistentialSubqueryBooleanExpression,
                public subquery : TableOp) {
        super(ast);
    }

    toString() {
        return `BooleanExpressionOp.ExistentialSubquery(${this.subquery})`;
    }
}

export class ComparisonSubquery extends BooleanExpressionOp {
    constructor(ast : Ast.ComparisonSubqueryBooleanExpression,
                public lhs : Ast.Value,
                public operator : string,
                public rhs : Ast.Value,
                public subquery : TableOp,
                public overload : Type[]|null) {
        super(ast);
    }

    toString() {
        return `BooleanExpressionOp.ComparisonSubquery(${this.lhs}, ${this.operator}, ${this.rhs}, ${this.subquery})`;
    }
}
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2018-2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21	import assert from 'assert';	2✔
22
23	import * as Ast from '../ast';	2✔
24	import Type from "../type";
25
26	import ReduceOp from './reduceop';
27
28	// Low-level ThingTalk operations
29	// Each ThingTalk AST node can be implemented in terms of these low-level ops
30	// Each of these ops can be compiled into JS code individually
31
32	// PointWiseOp : operates on each produced tuple
33	export class PointWiseOp {	2✔
34	}
35
36	export namespace PointWiseOp {	2!
37	export class Projection extends PointWiseOp {	2✔
38	constructor(public args : Set<string>) {	40✔
39	super();	40✔
40	}
41
42	toString() {
43	return `PointWiseOp.Projection(${this.args})`;	×
44	}
45	}
46
47	export class Compute extends PointWiseOp {	2✔
48	constructor(public expression : Ast.Value,	12✔
49	public alias : string) {	12✔
50	super();	12✔
51	}
52
53	toString() {
54	return `PointWiseOp.Compute(${this.expression} as ${this.alias})`;	×
55	}
56	}
57
58	export class BooleanCompute extends PointWiseOp {	2✔
59	constructor(public booleanExpression : Ast.BooleanExpression) {	2✔
60	super();	2✔
61	}
62
63	toString() {
64	return `PointWiseOp.BooleanCompute(${this.booleanExpression})`;	×
65	}
66	}
67	}
68
69	type SortHint = [string, 'asc'\|'desc'];
70	export class QueryInvocationHints {	2✔
71	projection : Set<string>;
72	filter : Ast.BooleanExpression;
73	sort : SortHint\|undefined;
74	limit : number\|undefined;
75
76	constructor(projection : Set<string>,
77	filter = Ast.BooleanExpression.True,	662✔
78	sort ?: SortHint,
79	limit ?: number) {
80	assert(filter instanceof Ast.BooleanExpression);	972✔
81	assert(sort === undefined \|\| Array.isArray(sort));	972✔
82	assert(projection instanceof Set);	972✔
83	assert(limit === undefined \|\| typeof limit === 'number');	972✔
84
85	this.filter = filter;	972✔
86	this.sort = sort;	972✔
87	this.projection = projection;	972✔
88	this.limit = limit;	972✔
89	}
90
91	clone() : QueryInvocationHints {
92	return new QueryInvocationHints(new Set(this.projection), this.filter, this.sort, this.limit);	310✔
93	}
94	}
95
96	/**
97	* A low-level operation on streams
98	*/
99	export abstract class StreamOp {	2✔
100	abstract ast : Ast.Expression\|null;
101	}
102
103	export namespace StreamOp {	2!
104	export class Now extends StreamOp {	2✔
105	constructor(public table : TableOp,	244✔
106	public ast : Ast.Expression) {	244✔
107	super();	244✔
108	}
109
110	toString() {
111	return `StreamOp.Now(${this.table})`;	×
112	}
113	}
114
115	export class InvokeVarRef extends StreamOp {	2✔
116	constructor(public name : string,	2✔
117	public in_params : Ast.InputParam[],	2✔
118	public ast : Ast.Expression,	2✔
119	public hints : QueryInvocationHints) {	2✔
120	super();	2✔
121	}
122
123	toString() {
124	return `StreamOp.InvokeVarRef(${this.name}, ${this.in_params.map((ip) => ip.prettyprint()).join(', ')})`;	×
125	}
126	}
127
128	export class InvokeSubscribe extends StreamOp {	2✔
129	constructor(public invocation : Ast.Invocation,	80✔
130	public ast : Ast.Expression,	80✔
131	public hints : QueryInvocationHints) {	80✔
132	super();	80✔
133	}
134
135	toString() {
136	return `StreamOp.InvokeSubscribe(${this.invocation.prettyprint()})`;	×
137	}
138	}
139
140	export class Timer extends StreamOp {	2✔
141	constructor(public base : Ast.Value\|undefined,	32✔
142	public interval : Ast.Value,	32✔
143	public frequency : Ast.Value\|undefined,	32✔
144	public ast : Ast.Expression) {	32✔
145	super();	32✔
146	}
147
148	toString() {
149	return `StreamOp.Timer(${this.base}, ${this.interval}, ${this.frequency})`;	×
150	}
151	}
152
153	export class AtTimer extends StreamOp {	2✔
154	constructor(public time : Ast.Value,	12✔
155	public expiration_date : Ast.Value\|undefined,	12✔
156	public ast : Ast.Expression) {	12✔
157	super();	12✔
158	}
159
160	toString() {
161	return `StreamOp.AtTimer(${this.time}, ${this.expiration_date})`;	×
162	}
163	}
164
165	export class OnTimer extends StreamOp {	2✔
166	constructor(public date : Ast.Value,	6✔
167	public ast : Ast.Expression) {	6✔
168	super();	6✔
169	}
170
171	toString() {
172	return `StreamOp.OnTimer(${this.date})`;	×
173	}
174	}
175
176	export class Filter extends StreamOp {	2✔
177	constructor(public stream : StreamOp,	30✔
178	public filter : BooleanExpressionOp,	30✔
179	public ast : Ast.Expression) {	30✔
180	super();	30✔
181	}
182
183	toString() {
184	return `StreamOp.Filter(${this.stream}, ${this.filter})`;	×
185	}
186	}
187
188	export class Map extends StreamOp {	2✔
189	constructor(public stream : StreamOp,	×
190	public op : PointWiseOp,	×
191	public ast : Ast.Expression) {	×
192	super();	×
193	}
194
195	toString() {
196	return `StreamOp.Map(${this.stream}, ${this.op})`;	×
197	}
198	}
199
200	export class EdgeNew extends StreamOp {	2✔
201	constructor(public stream : StreamOp,	86✔
202	public ast : Ast.Expression) {	86✔
203	super();	86✔
204	}
205
206	toString() {
207	return `StreamOp.EdgeNew(${this.stream})`;	×
208	}
209	}
210
211	export class EdgeFilter extends StreamOp {	2✔
212	constructor(public stream : StreamOp,	2✔
213	public filter : BooleanExpressionOp,	2✔
214	public ast : Ast.Expression) {	2✔
215	super();	2✔
216	}
217
218	toString() {
219	return `StreamOp.EdgeFilter(${this.stream}, ${this.filter})`;	×
220	}
221	}
222
223	export class Union extends StreamOp {	2✔
224	constructor(public lhs : StreamOp,	4✔
225	public rhs : StreamOp,	4✔
226	public ast : Ast.Expression) {	4✔
227	super();	4✔
228	}
229
230	toString() {
231	return `StreamOp.Union(${this.lhs}, ${this.rhs})`;	×
232	}
233	}
234
235	/**
236	When the stream fires, get the whole table (ignore the stream).
237	This is used to implement certain "monitor(table)" where the
238	table needs to be recomputed on subscribe.
239	*/
240	export class InvokeTable extends StreamOp {	2✔
241	constructor(public stream : StreamOp,	2✔
242	public table : TableOp,	2✔
243	public ast : Ast.Expression) {	2✔
244	super();	2✔
245	}
246
247	toString() {
248	return `StreamOp.InvokeTable(${this.stream}, ${this.table})`;	×
249	}
250	}
251
252	/**
253	* When the stream fires, get the whole table and join it.
254	*/
255	export class Join extends StreamOp {	2✔
256	constructor(public stream : StreamOp,	40✔
257	public table : TableOp,	40✔
258	public ast : Ast.Expression) {	40✔
259	super();	40✔
260	}
261
262	toString() {
263	return `StreamOp.Join(${this.stream}, ${this.table})`;	×
264	}
265	}
266	}
267
268	type UnaryStreamOp = StreamOp.Filter \| StreamOp.Map \| StreamOp.EdgeFilter \| StreamOp.EdgeNew;
269	export function isUnaryStreamOp(op : StreamOp) : op is UnaryStreamOp {	2✔
270	return op instanceof StreamOp.Filter \|\|	482✔
271	op instanceof StreamOp.Map \|\|
272	op instanceof StreamOp.EdgeFilter \|\|
273	op instanceof StreamOp.EdgeNew;
274	}
275
276	/**
277	* A low-level operation on an in-memory table.
278	*/
279	export abstract class TableOp {	2✔
280	handle_thingtalk = false;	624✔
281	abstract device : Ast.DeviceSelector\|null;
282	abstract ast : Ast.Expression;
283	}
284
285	export namespace TableOp {	2!
286	export class InvokeVarRef extends TableOp {	2✔
287	device = null;	58✔
288
289	constructor(public name : string,	58✔
290	public in_params : Ast.InputParam[],	58✔
291	public ast : Ast.Expression,	58✔
292	public hints : QueryInvocationHints) {	58✔
293	super();	58✔
294	}
295
296	toString() {
297	return `TableOp.InvokeVarRef(${this.name}, ${this.in_params.map((ip) => ip.prettyprint())})`;	×
298	}
299	}
300
301	export class InvokeGet extends TableOp {	2✔
302	constructor(public invocation : Ast.Invocation,	292✔
303	public device : Ast.DeviceSelector\|null,	292✔
304	public handle_thingtalk : boolean,	292✔
305	public ast : Ast.Expression,	292✔
306	public hints : QueryInvocationHints) {	292✔
307	super();	292✔
308	}
309
310	toString() {
311	return `TableOp.InvokeGet(${this.invocation.prettyprint()})`;	×
312	}
313	}
314
315	export class Filter extends TableOp {	2✔
316	constructor(public table : TableOp,	88✔
317	public filter : BooleanExpressionOp,	88✔
318	public device : Ast.DeviceSelector\|null,	88✔
319	public handle_thingtalk : boolean,	88✔
320	public ast : Ast.Expression) {	88✔
321	super();	88✔
322	}
323
324	toString() {
325	return `TableOp.Filter(${this.table}, ${this.filter})`;	×
326	}
327	}
328
329	export class Map extends TableOp {	2✔
330	constructor(public table : TableOp,	54✔
331	public op : PointWiseOp,	54✔
332	public device : Ast.DeviceSelector\|null,	54✔
333	public handle_thingtalk : boolean,	54✔
334	public ast : Ast.Expression) {	54✔
335	super();	54✔
336	}
337
338	toString() {
339	return `TableOp.Map(${this.table}, ${this.op})`;	×
340	}
341	}
342
343	export class Reduce extends TableOp {	2✔
344	constructor(public table : TableOp,	112✔
345	public op : ReduceOp<unknown>,	112✔
346	public device : Ast.DeviceSelector\|null,	112✔
347	public handle_thingtalk : boolean,	112✔
348	public ast : Ast.Expression) {	112✔
349	super();	112✔
350	}
351
352	toString() {
353	return `TableOp.Reduce(${this.table}, ${this.op})`;	×
354	}
355	}
356
357	export class Join extends TableOp {	2✔
358	constructor(public lhs : TableOp,	2✔
359	public rhs : TableOp,	2✔
360	public condition : BooleanExpressionOp\|null,	2✔
361	public device : Ast.DeviceSelector\|null,	2✔
362	public handle_thingtalk : boolean,	2✔
363	public ast : Ast.Expression) {	2✔
364	super();	2✔
365	}
366
367	toString() {
NEW 368	return `TableOp.Join(${this.lhs}, ${this.rhs}, ${this.condition})`;	×
369	}
370	}
371
372	export class CrossJoin extends TableOp {	2✔
373	constructor(public lhs : TableOp,	8✔
374	public rhs : TableOp,	8✔
375	public device : Ast.DeviceSelector\|null,	8✔
376	public handle_thingtalk : boolean,	8✔
377	public ast : Ast.Expression) {	8✔
378	super();	8✔
379	}
380
381	toString() {
382	return `TableOp.CrossJoin(${this.lhs}, ${this.rhs})`;	×
383	}
384	}
385
386	export class NestedLoopJoin extends TableOp {	2✔
387	constructor(public lhs : TableOp,	10✔
388	public rhs : TableOp,	10✔
389	public device : Ast.DeviceSelector\|null,	10✔
390	public handle_thingtalk : boolean,	10✔
391	public ast : Ast.Expression) {	10✔
392	super();	10✔
393	}
394
395	toString() {
396	return `TableOp.NestedLoopJoin(${this.lhs}, ${this.rhs})`;	×
397	}
398	}
399	}
400
401	type UnaryTableOp = TableOp.Filter \| TableOp.Map \| TableOp.Reduce;
402	export function isUnaryTableOp(op : TableOp) : op is UnaryTableOp {	2✔
403	return op instanceof TableOp.Filter \|\|	66✔
404	op instanceof TableOp.Map \|\|
405	op instanceof TableOp.Reduce;
406	}
407
408	export abstract class ActionOp {	2✔
409
410	}
411
412	export namespace ActionOp {	2!
413	export class InvokeDo extends ActionOp {	2✔
414	constructor(public invocation : Ast.Invocation,	160✔
415	public ast : Ast.Expression) {	160✔
416	super();	160✔
417	}
418
419	toString() {
420	return `ActionOp.InvokeDo(${this.invocation.prettyprint()})`;	×
421	}
422	}
423
424	export class InvokeVarRef extends ActionOp {	2✔
425	constructor(public name : string,	58✔
426	public in_params : Ast.InputParam[],	58✔
427	public ast : Ast.Expression) {	58✔
428	super();	58✔
429	}
430
431	toString() {
432	return `ActionOp.InvokeVarRef(${this.name}, ${this.in_params.map((ip) => ip.prettyprint())})`;	×
433	}
434	}
435	}
436
437	/**
438	* The overall structure of the rule.
439	* This reflects the overall "when => get* => do" structure of ThingTalk
440	* which is what it optimizes for.
441	*/
442	export class RuleOp {	2✔
443	constructor(public stream : StreamOp\|null,	470✔
444	public action : ActionOp\|null,	470✔
445	public ast : Ast.ExpressionStatement\|Ast.ReturnStatement) {	470✔
446	}
447
448	toString() {
449	return `RuleOp(${this.stream}, ${this.action})`;	×
450	}
451	}
452
453	export abstract class BooleanExpressionOp {	2✔
454	static True : ConstantBooleanExpressionOp;
455	static False : ConstantBooleanExpressionOp;
456
457	public ast : Ast.BooleanExpression;
458
459	protected constructor(ast : Ast.BooleanExpression) {
460	this.ast = ast;	176✔
461	}
462	}
463
464	class ConstantBooleanExpressionOp extends BooleanExpressionOp {
465	constructor(public readonly value : boolean) {	4✔
466	super(value ? Ast.BooleanExpression.True : Ast.BooleanExpression.False);	4✔
467	}
468
469	toString() {
470	return `BooleanExpressionOp.Constant(${this.value})`;	×
471	}
472	}
473	BooleanExpressionOp.True = new ConstantBooleanExpressionOp(true);	2✔
474	BooleanExpressionOp.False = new ConstantBooleanExpressionOp(false);	2✔
475
476	export namespace BooleanExpressionOp {	2!
477	export class And extends BooleanExpressionOp {	2✔
478	constructor(ast : Ast.AndBooleanExpression,
479	public operands : BooleanExpressionOp[]) {	14✔
480	super(ast);	14✔
481	}
482
483	toString() {
484	return `BooleanExpressionOp.And(${this.operands.join(', ')})`;	×
485	}
486	}
487
488	export class Or extends BooleanExpressionOp {	2✔
489	constructor(ast : Ast.OrBooleanExpression,
490	public operands : BooleanExpressionOp[]) {	6✔
491	super(ast);	6✔
492	}
493
494	toString() {
495	return `BooleanExpressionOp.Or(${this.operands.join(', ')})`;	×
496	}
497	}
498
499	export class Not extends BooleanExpressionOp {	2✔
500	constructor(ast : Ast.NotBooleanExpression,
501	public expr : BooleanExpressionOp) {	4✔
502	super(ast);	4✔
503	}
504
505	toString() {
506	return `BooleanExpressionOp.Not(${this.expr})`;	×
507	}
508	}
509
510	export class Atom extends BooleanExpressionOp {	2✔
511	constructor(ast : Ast.AtomBooleanExpression\|Ast.ComputeBooleanExpression,
512	public lhs : Ast.Value,	130✔
513	public operator : string,	130✔
514	public rhs : Ast.Value,	130✔
515	public overload : Type[]\|null){	130✔
516	super(ast);	130✔
517	}
518
519	toString() {
520	return `BooleanExpressionOp.Atom(${this.lhs}, ${this.operator}, ${this.rhs})`;	×
521	}
522	}
523
524	export class ExistentialSubquery extends BooleanExpressionOp {	2✔
525	constructor(ast : Ast.ExistentialSubqueryBooleanExpression,
526	public subquery : TableOp) {	10✔
527	super(ast);	10✔
528	}
529
530	toString() {
531	return `BooleanExpressionOp.ExistentialSubquery(${this.subquery})`;	×
532	}
533	}
534
535	export class ComparisonSubquery extends BooleanExpressionOp {	2✔
536	constructor(ast : Ast.ComparisonSubqueryBooleanExpression,
537	public lhs : Ast.Value,	8✔
538	public operator : string,	8✔
539	public rhs : Ast.Value,	8✔
540	public subquery : TableOp,	8✔
541	public overload : Type[]\|null) {	8✔
542	super(ast);	8✔
543	}
544
545	toString() {
546	return `BooleanExpressionOp.ComparisonSubquery(${this.lhs}, ${this.operator}, ${this.rhs}, ${this.subquery})`;	×
547	}
548	}
549	}

stanford-oval / thingtalk / 1505

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous