-
Notifications
You must be signed in to change notification settings - Fork 2.1k
/
ir.ts
186 lines (159 loc) Β· 4.31 KB
/
ir.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
import { VectorStore } from "../vectorstores.js";
/**
* Represents logical AND operator.
*/
export type AND = "and";
/**
* Represents logical OR operator.
*/
export type OR = "or";
/**
* Represents logical NOT operator.
*/
export type NOT = "not";
/**
* Represents a logical operator which can be AND, OR, or NOT.
*/
export type Operator = AND | OR | NOT;
/**
* Represents equality comparison operator.
*/
export type EQ = "eq";
/**
* Represents inequality comparison operator.
*/
export type NE = "ne";
/**
* Represents less than comparison operator.
*/
export type LT = "lt";
/**
* Represents greater than comparison operator.
*/
export type GT = "gt";
/**
* Represents less than or equal to comparison operator.
*/
export type LTE = "lte";
/**
* Represents greater than or equal to comparison operator.
*/
export type GTE = "gte";
/**
* Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or
* GTE.
*/
export type Comparator = EQ | NE | LT | GT | LTE | GTE;
export const Operators: { [key: string]: Operator } = {
and: "and",
or: "or",
not: "not",
};
export const Comparators: { [key: string]: Comparator } = {
eq: "eq",
ne: "ne",
lt: "lt",
gt: "gt",
lte: "lte",
gte: "gte",
};
/**
* Represents the result of visiting an operation or comparison
* expression.
*/
export type VisitorResult = VisitorOperationResult | VisitorComparisonResult;
/**
* Represents the result of visiting an operation expression.
*/
export type VisitorOperationResult = {
[operator: string]: VisitorResult[];
};
/**
* Represents the result of visiting a comparison expression.
*/
export type VisitorComparisonResult = {
[attr: string]: {
[comparator: string]: string | number;
};
};
/**
* Represents the result of visiting a structured query expression.
*/
export type VisitorStructuredQueryResult = {
filter?: VisitorComparisonResult | VisitorOperationResult;
};
/**
* Abstract class for visiting expressions. Subclasses must implement
* visitOperation, visitComparison, and visitStructuredQuery methods.
*/
export abstract class Visitor<T extends VectorStore = VectorStore> {
declare VisitOperationOutput: object;
declare VisitComparisonOutput: object;
declare VisitStructuredQueryOutput: { filter?: T["FilterType"] };
abstract allowedOperators: Operator[];
abstract allowedComparators: Comparator[];
abstract visitOperation(operation: Operation): this["VisitOperationOutput"];
abstract visitComparison(
comparison: Comparison
): this["VisitComparisonOutput"];
abstract visitStructuredQuery(
structuredQuery: StructuredQuery
): this["VisitStructuredQueryOutput"];
}
/**
* Abstract class representing an expression. Subclasses must implement
* the exprName property and the accept method.
*/
export abstract class Expression {
abstract exprName: "Operation" | "Comparison" | "StructuredQuery";
accept(visitor: Visitor) {
if (this.exprName === "Operation") {
return visitor.visitOperation(this as unknown as Operation);
} else if (this.exprName === "Comparison") {
return visitor.visitComparison(this as unknown as Comparison);
} else if (this.exprName === "StructuredQuery") {
return visitor.visitStructuredQuery(this as unknown as StructuredQuery);
} else {
throw new Error("Unknown Expression type");
}
}
}
/**
* Abstract class representing a filter directive. It extends the
* Expression class.
*/
export abstract class FilterDirective extends Expression {}
/**
* Class representing a comparison filter directive. It extends the
* FilterDirective class.
*/
export class Comparison extends FilterDirective {
exprName = "Comparison" as const;
constructor(
public comparator: Comparator,
public attribute: string,
public value: string | number
) {
super();
}
}
/**
* Class representing an operation filter directive. It extends the
* FilterDirective class.
*/
export class Operation extends FilterDirective {
exprName = "Operation" as const;
constructor(public operator: Operator, public args?: FilterDirective[]) {
super();
}
}
/**
* Class representing a structured query expression. It extends the
* Expression class.
*/
export class StructuredQuery extends Expression {
exprName = "StructuredQuery" as const;
constructor(public query: string, public filter?: FilterDirective) {
super();
}
}