1400

pending completion

Build # 1400

Build Type

Pull #354

travis-ci-com

Committed by

web-flow

Commit Message

Merge f637ac7f3 into fa737b3fc

Pull Request Pull Request #354: Add history query

Run Details

4451 of 6251 branches covered (71.2%)

Branch coverage included in aggregate %.

29 of 54 new or added lines in 7 files covered. (53.7%)

39 existing lines in 1 file now uncovered.

10208 of 12669 relevant lines covered (80.57%)

47450.51 hits per line

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

81.78

/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})`;
    }
}
}

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 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 HistoryQuery extends TableOp {
    constructor(public device : Ast.DeviceSelector|null,
                public channel : string,
                public ast : Ast.Expression) {
        super();
    }

    toString() {
        return `TableOp.History(${this.device}, ${this.channel})`;
    }
}

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 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
59	type SortHint = [string, 'asc'\|'desc'];
60	export class QueryInvocationHints {	2✔
61	projection : Set<string>;
62	filter : Ast.BooleanExpression;
63	sort : SortHint\|undefined;
64	limit : number\|undefined;
65
66	constructor(projection : Set<string>,
67	filter = Ast.BooleanExpression.True,	642✔
68	sort ?: SortHint,
69	limit ?: number) {
70	assert(filter instanceof Ast.BooleanExpression);	950✔
71	assert(sort === undefined \|\| Array.isArray(sort));	950✔
72	assert(projection instanceof Set);	950✔
73	assert(limit === undefined \|\| typeof limit === 'number');	950✔
74
75	this.filter = filter;	950✔
76	this.sort = sort;	950✔
77	this.projection = projection;	950✔
78	this.limit = limit;	950✔
79	}
80
81	clone() : QueryInvocationHints {
82	return new QueryInvocationHints(new Set(this.projection), this.filter, this.sort, this.limit);	308✔
83	}
84	}
85
86	/**
87	* A low-level operation on streams
88	*/
89	export abstract class StreamOp {	2✔
90	abstract ast : Ast.Expression\|null;
91	}
92
93	export namespace StreamOp {	2!
94	export class Now extends StreamOp {	2✔
95	constructor(public table : TableOp,	240✔
96	public ast : Ast.Expression) {	240✔
97	super();	240✔
98	}
99
100	toString() {
101	return `StreamOp.Now(${this.table})`;	×
102	}
103	}
104
105	export class InvokeVarRef extends StreamOp {	2✔
106	constructor(public name : string,	2✔
107	public in_params : Ast.InputParam[],	2✔
108	public ast : Ast.Expression,	2✔
109	public hints : QueryInvocationHints) {	2✔
110	super();	2✔
111	}
112
113	toString() {
114	return `StreamOp.InvokeVarRef(${this.name}, ${this.in_params.map((ip) => ip.prettyprint()).join(', ')})`;	×
115	}
116	}
117
118	export class InvokeSubscribe extends StreamOp {	2✔
119	constructor(public invocation : Ast.Invocation,	80✔
120	public ast : Ast.Expression,	80✔
121	public hints : QueryInvocationHints) {	80✔
122	super();	80✔
123	}
124
125	toString() {
126	return `StreamOp.InvokeSubscribe(${this.invocation.prettyprint()})`;	×
127	}
128	}
129
130	export class Timer extends StreamOp {	2✔
131	constructor(public base : Ast.Value\|undefined,	32✔
132	public interval : Ast.Value,	32✔
133	public frequency : Ast.Value\|undefined,	32✔
134	public ast : Ast.Expression) {	32✔
135	super();	32✔
136	}
137
138	toString() {
139	return `StreamOp.Timer(${this.base}, ${this.interval}, ${this.frequency})`;	×
140	}
141	}
142
143	export class AtTimer extends StreamOp {	2✔
144	constructor(public time : Ast.Value,	12✔
145	public expiration_date : Ast.Value\|undefined,	12✔
146	public ast : Ast.Expression) {	12✔
147	super();	12✔
148	}
149
150	toString() {
151	return `StreamOp.AtTimer(${this.time}, ${this.expiration_date})`;	×
152	}
153	}
154
155	export class Filter extends StreamOp {	2✔
156	constructor(public stream : StreamOp,	30✔
157	public filter : BooleanExpressionOp,	30✔
158	public ast : Ast.Expression) {	30✔
159	super();	30✔
160	}
161
162	toString() {
163	return `StreamOp.Filter(${this.stream}, ${this.filter})`;	×
164	}
165	}
166
167	export class Map extends StreamOp {	2✔
168	constructor(public stream : StreamOp,	×
169	public op : PointWiseOp,	×
170	public ast : Ast.Expression) {	×
171	super();	×
172	}
173
174	toString() {
175	return `StreamOp.Map(${this.stream}, ${this.op})`;	×
176	}
177	}
178
179	export class EdgeNew extends StreamOp {	2✔
180	constructor(public stream : StreamOp,	86✔
181	public ast : Ast.Expression) {	86✔
182	super();	86✔
183	}
184
185	toString() {
186	return `StreamOp.EdgeNew(${this.stream})`;	×
187	}
188	}
189
190	export class EdgeFilter extends StreamOp {	2✔
191	constructor(public stream : StreamOp,	2✔
192	public filter : BooleanExpressionOp,	2✔
193	public ast : Ast.Expression) {	2✔
194	super();	2✔
195	}
196
197	toString() {
198	return `StreamOp.EdgeFilter(${this.stream}, ${this.filter})`;	×
199	}
200	}
201
202	export class Union extends StreamOp {	2✔
203	constructor(public lhs : StreamOp,	4✔
204	public rhs : StreamOp,	4✔
205	public ast : Ast.Expression) {	4✔
206	super();	4✔
207	}
208
209	toString() {
210	return `StreamOp.Union(${this.lhs}, ${this.rhs})`;	×
211	}
212	}
213
214	/**
215	When the stream fires, get the whole table (ignore the stream).
216	This is used to implement certain "monitor(table)" where the
217	table needs to be recomputed on subscribe.
218	*/
219	export class InvokeTable extends StreamOp {	2✔
220	constructor(public stream : StreamOp,	2✔
221	public table : TableOp,	2✔
222	public ast : Ast.Expression) {	2✔
223	super();	2✔
224	}
225
226	toString() {
227	return `StreamOp.InvokeTable(${this.stream}, ${this.table})`;	×
228	}
229	}
230
231	/**
232	* When the stream fires, get the whole table and join it.
233	*/
234	export class Join extends StreamOp {	2✔
235	constructor(public stream : StreamOp,	40✔
236	public table : TableOp,	40✔
237	public ast : Ast.Expression) {	40✔
238	super();	40✔
239	}
240
241	toString() {
242	return `StreamOp.Join(${this.stream}, ${this.table})`;	×
243	}
244	}
245	}
246
247	type UnaryStreamOp = StreamOp.Filter \| StreamOp.Map \| StreamOp.EdgeFilter \| StreamOp.EdgeNew;
248	export function isUnaryStreamOp(op : StreamOp) : op is UnaryStreamOp {	2✔
249	return op instanceof StreamOp.Filter \|\|	472✔
250	op instanceof StreamOp.Map \|\|
251	op instanceof StreamOp.EdgeFilter \|\|
252	op instanceof StreamOp.EdgeNew;
253	}
254
255	/**
256	* A low-level operation on an in-memory table.
257	*/
258	export abstract class TableOp {	2✔
259	handle_thingtalk = false;	614✔
260	abstract device : Ast.DeviceSelector\|null;
261	abstract ast : Ast.Expression;
262	}
263
264	export namespace TableOp {	2!
265	export class InvokeVarRef extends TableOp {	2✔
266	device = null;	58✔
267
268	constructor(public name : string,	58✔
269	public in_params : Ast.InputParam[],	58✔
270	public ast : Ast.Expression,	58✔
271	public hints : QueryInvocationHints) {	58✔
272	super();	58✔
273	}
274
275	toString() {
276	return `TableOp.InvokeVarRef(${this.name}, ${this.in_params.map((ip) => ip.prettyprint())})`;	×
277	}
278	}
279
280	export class InvokeGet extends TableOp {	2✔
281	constructor(public invocation : Ast.Invocation,	286✔
282	public device : Ast.DeviceSelector\|null,	286✔
283	public handle_thingtalk : boolean,	286✔
284	public ast : Ast.Expression,	286✔
285	public hints : QueryInvocationHints) {	286✔
286	super();	286✔
287	}
288
289	toString() {
290	return `TableOp.InvokeGet(${this.invocation.prettyprint()})`;	×
291	}
292	}
293
294	export class HistoryQuery extends TableOp {	2✔
NEW 295	constructor(public device : Ast.DeviceSelector\|null,	×
NEW 296	public channel : string,	×
NEW 297	public ast : Ast.Expression) {	×
NEW 298	super();	×
299	}
300
301	toString() {
NEW 302	return `TableOp.History(${this.device}, ${this.channel})`;	×
303	}
304	}
305
306	export class Filter extends TableOp {	2✔
307	constructor(public table : TableOp,	88✔
308	public filter : BooleanExpressionOp,	88✔
309	public device : Ast.DeviceSelector\|null,	88✔
310	public handle_thingtalk : boolean,	88✔
311	public ast : Ast.Expression) {	88✔
312	super();	88✔
313	}
314
315	toString() {
316	return `TableOp.Filter(${this.table}, ${this.filter})`;	×
317	}
318	}
319
320	export class Map extends TableOp {	2✔
321	constructor(public table : TableOp,	52✔
322	public op : PointWiseOp,	52✔
323	public device : Ast.DeviceSelector\|null,	52✔
324	public handle_thingtalk : boolean,	52✔
325	public ast : Ast.Expression) {	52✔
326	super();	52✔
327	}
328
329	toString() {
330	return `TableOp.Map(${this.table}, ${this.op})`;	×
331	}
332	}
333
334	export class Reduce extends TableOp {	2✔
335	constructor(public table : TableOp,	112✔
336	public op : ReduceOp<unknown>,	112✔
337	public device : Ast.DeviceSelector\|null,	112✔
338	public handle_thingtalk : boolean,	112✔
339	public ast : Ast.Expression) {	112✔
340	super();	112✔
341	}
342
343	toString() {
344	return `TableOp.Reduce(${this.table}, ${this.op})`;	×
345	}
346	}
347
348	export class CrossJoin extends TableOp {	2✔
349	constructor(public lhs : TableOp,	8✔
350	public rhs : TableOp,	8✔
351	public device : Ast.DeviceSelector\|null,	8✔
352	public handle_thingtalk : boolean,	8✔
353	public ast : Ast.Expression) {	8✔
354	super();	8✔
355	}
356
357	toString() {
358	return `TableOp.CrossJoin(${this.lhs}, ${this.rhs})`;	×
359	}
360	}
361
362	export class NestedLoopJoin extends TableOp {	2✔
363	constructor(public lhs : TableOp,	10✔
364	public rhs : TableOp,	10✔
365	public device : Ast.DeviceSelector\|null,	10✔
366	public handle_thingtalk : boolean,	10✔
367	public ast : Ast.Expression) {	10✔
368	super();	10✔
369	}
370
371	toString() {
372	return `TableOp.NestedLoopJoin(${this.lhs}, ${this.rhs})`;	×
373	}
374	}
375	}
376
377	type UnaryTableOp = TableOp.Filter \| TableOp.Map \| TableOp.Reduce;
378	export function isUnaryTableOp(op : TableOp) : op is UnaryTableOp {	2✔
379	return op instanceof TableOp.Filter \|\|	66✔
380	op instanceof TableOp.Map \|\|
381	op instanceof TableOp.Reduce;
382	}
383
384	export abstract class ActionOp {	2✔
385
386	}
387
388	export namespace ActionOp {	2!
389	export class InvokeDo extends ActionOp {	2✔
390	constructor(public invocation : Ast.Invocation,	156✔
391	public ast : Ast.Expression) {	156✔
392	super();	156✔
393	}
394
395	toString() {
396	return `ActionOp.InvokeDo(${this.invocation.prettyprint()})`;	×
397	}
398	}
399
400	export class InvokeVarRef extends ActionOp {	2✔
401	constructor(public name : string,	58✔
402	public in_params : Ast.InputParam[],	58✔
403	public ast : Ast.Expression) {	58✔
404	super();	58✔
405	}
406
407	toString() {
408	return `ActionOp.InvokeVarRef(${this.name}, ${this.in_params.map((ip) => ip.prettyprint())})`;	×
409	}
410	}
411	}
412
413	/**
414	* The overall structure of the rule.
415	* This reflects the overall "when => get* => do" structure of ThingTalk
416	* which is what it optimizes for.
417	*/
418	export class RuleOp {	2✔
419	constructor(public stream : StreamOp\|null,	460✔
420	public action : ActionOp\|null,	460✔
421	public ast : Ast.ExpressionStatement\|Ast.ReturnStatement) {	460✔
422	}
423
424	toString() {
425	return `RuleOp(${this.stream}, ${this.action})`;	×
426	}
427	}
428
429	export abstract class BooleanExpressionOp {	2✔
430	static True : ConstantBooleanExpressionOp;
431	static False : ConstantBooleanExpressionOp;
432
433	public ast : Ast.BooleanExpression;
434
435	protected constructor(ast : Ast.BooleanExpression) {
436	this.ast = ast;	172✔
437	}
438	}
439
440	class ConstantBooleanExpressionOp extends BooleanExpressionOp {
441	constructor(public readonly value : boolean) {	4✔
442	super(value ? Ast.BooleanExpression.True : Ast.BooleanExpression.False);	4✔
443	}
444
445	toString() {
446	return `BooleanExpressionOp.Constant(${this.value})`;	×
447	}
448	}
449	BooleanExpressionOp.True = new ConstantBooleanExpressionOp(true);	2✔
450	BooleanExpressionOp.False = new ConstantBooleanExpressionOp(false);	2✔
451
452	export namespace BooleanExpressionOp {	2!
453	export class And extends BooleanExpressionOp {	2✔
454	constructor(ast : Ast.AndBooleanExpression,
455	public operands : BooleanExpressionOp[]) {	14✔
456	super(ast);	14✔
457	}
458
459	toString() {
460	return `BooleanExpressionOp.And(${this.operands.join(', ')})`;	×
461	}
462	}
463
464	export class Or extends BooleanExpressionOp {	2✔
465	constructor(ast : Ast.OrBooleanExpression,
466	public operands : BooleanExpressionOp[]) {	6✔
467	super(ast);	6✔
468	}
469
470	toString() {
471	return `BooleanExpressionOp.Or(${this.operands.join(', ')})`;	×
472	}
473	}
474
475	export class Not extends BooleanExpressionOp {	2✔
476	constructor(ast : Ast.NotBooleanExpression,
477	public expr : BooleanExpressionOp) {	4✔
478	super(ast);	4✔
479	}
480
481	toString() {
482	return `BooleanExpressionOp.Not(${this.expr})`;	×
483	}
484	}
485
486	export class Atom extends BooleanExpressionOp {	2✔
487	constructor(ast : Ast.AtomBooleanExpression\|Ast.ComputeBooleanExpression,
488	public lhs : Ast.Value,	126✔
489	public operator : string,	126✔
490	public rhs : Ast.Value,	126✔
491	public overload : Type[]\|null){	126✔
492	super(ast);	126✔
493	}
494
495	toString() {
496	return `BooleanExpressionOp.Atom(${this.lhs}, ${this.operator}, ${this.rhs})`;	×
497	}
498	}
499
500	export class ExistentialSubquery extends BooleanExpressionOp {	2✔
501	constructor(ast : Ast.ExistentialSubqueryBooleanExpression,
502	public subquery : TableOp) {	10✔
503	super(ast);	10✔
504	}
505
506	toString() {
507	return `BooleanExpressionOp.ExistentialSubquery(${this.subquery})`;	×
508	}
509	}
510
511	export class ComparisonSubquery extends BooleanExpressionOp {	2✔
512	constructor(ast : Ast.ComparisonSubqueryBooleanExpression,
513	public lhs : Ast.Value,	8✔
514	public operator : string,	8✔
515	public rhs : Ast.Value,	8✔
516	public subquery : TableOp,	8✔
517	public overload : Type[]\|null) {	8✔
518	super(ast);	8✔
519	}
520
521	toString() {
522	return `BooleanExpressionOp.ComparisonSubquery(${this.lhs}, ${this.operator}, ${this.rhs}, ${this.subquery})`;	×
523	}
524	}
525	}

stanford-oval / thingtalk / 1400

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