9
9
10
10
final class AlternativeLoader implements StepBuilderInterface
11
11
{
12
- /** @var array<array-key, array{value: Node\Expr, type: string}> */
12
+ /** @var array<array-key, array{value: Node\Expr, iterable: bool, type: string}> */
13
13
private array $ parameters = [];
14
14
15
15
public function __construct (private readonly Node \Expr $ query )
@@ -31,71 +31,78 @@ public function withState(Node\Expr $state): StepBuilderInterface
31
31
return $ this ;
32
32
}
33
33
34
- public function addStringParam (int |string $ key , Node \Expr $ param ): StepBuilderInterface
34
+ public function addStringParam (int |string $ key , Node \Expr $ param, null | bool $ iterable = false ): StepBuilderInterface
35
35
{
36
36
$ this ->parameters [$ key ] = [
37
37
'value ' => $ param ,
38
38
'type ' => 'string ' ,
39
+ 'iterable ' => $ iterable ,
39
40
];
40
41
41
42
return $ this ;
42
43
}
43
44
44
- public function addIntegerParam (int |string $ key , Node \Expr $ param ): StepBuilderInterface
45
+ public function addIntegerParam (int |string $ key , Node \Expr $ param, null | bool $ iterable = false ): StepBuilderInterface
45
46
{
46
47
$ this ->parameters [$ key ] = [
47
48
'value ' => $ param ,
48
49
'type ' => 'integer ' ,
50
+ 'iterable ' => $ iterable ,
49
51
];
50
52
51
53
return $ this ;
52
54
}
53
55
54
- public function addBooleanParam (int |string $ key , Node \Expr $ param ): StepBuilderInterface
56
+ public function addBooleanParam (int |string $ key , Node \Expr $ param, null | bool $ iterable = false ): StepBuilderInterface
55
57
{
56
58
$ this ->parameters [$ key ] = [
57
59
'value ' => $ param ,
58
60
'type ' => 'boolean ' ,
61
+ 'iterable ' => $ iterable ,
59
62
];
60
63
61
64
return $ this ;
62
65
}
63
66
64
- public function addDateParam (int |string $ key , Node \Expr $ param ): self
67
+ public function addDateParam (int |string $ key , Node \Expr $ param, null | bool $ iterable = false ): self
65
68
{
66
69
$ this ->parameters [$ key ] = [
67
70
'value ' => $ param ,
68
71
'type ' => 'date ' ,
72
+ 'iterable ' => $ iterable ,
69
73
];
70
74
71
75
return $ this ;
72
76
}
73
77
74
- public function addDateTimeParam (int |string $ key , Node \Expr $ param ): self
78
+ public function addDateTimeParam (int |string $ key , Node \Expr $ param, null | bool $ iterable = false ): self
75
79
{
76
80
$ this ->parameters [$ key ] = [
77
81
'value ' => $ param ,
78
82
'type ' => 'datetime ' ,
83
+ 'iterable ' => $ iterable ,
79
84
];
80
85
81
86
return $ this ;
82
87
}
83
88
84
- public function addJSONParam (int |string $ key , Node \Expr $ param ): self
89
+ public function addJSONParam (int |string $ key , Node \Expr $ param, null | bool $ iterable = false ): self
85
90
{
86
91
$ this ->parameters [$ key ] = [
87
92
'value ' => $ param ,
88
93
'type ' => 'json ' ,
94
+ 'iterable ' => $ iterable ,
89
95
];
90
96
91
97
return $ this ;
92
98
}
93
99
94
- public function addBinaryParam (int |string $ key , Node \Expr $ param ): self
100
+ public function addBinaryParam (int |string $ key , Node \Expr $ param, null | bool $ iterable = false ): self
95
101
{
96
102
$ this ->parameters [$ key ] = [
97
103
'value ' => $ param ,
98
104
'type ' => 'binary ' ,
105
+ 'iterable ' => $ iterable ,
99
106
];
100
107
101
108
return $ this ;
@@ -126,7 +133,7 @@ public function getNode(): Node
126
133
)
127
134
)
128
135
),
129
- ...$ this ->compileParameters (),
136
+ ...$ this ->getParameters (),
130
137
new Node \Stmt \Expression (
131
138
expr: new Node \Expr \MethodCall (
132
139
var: new Node \Expr \Variable ('statement ' ),
@@ -147,115 +154,135 @@ public function getNode(): Node
147
154
);
148
155
}
149
156
150
- public function compileParameters (): iterable
157
+ public function getParameters (): iterable
151
158
{
152
159
foreach ($ this ->parameters as $ key => $ parameter ) {
153
- yield match ($ parameter ['type ' ]) {
154
- 'datetime ' => new Node \Stmt \Expression (
155
- new Node \Expr \MethodCall (
156
- var: new Node \Expr \Variable ('statement ' ),
157
- name: new Node \Identifier ('bindValue ' ),
158
- args: [
159
- new Node \Arg (
160
- \is_string ($ key ) ? new Node \Scalar \Encapsed (
161
- [
162
- new Node \Scalar \EncapsedStringPart (': ' ),
163
- new Node \Scalar \EncapsedStringPart ($ key ),
164
- ]
165
- ) : new Node \Scalar \LNumber ($ key )
166
- ),
167
- new Node \Arg (
168
- value: new Node \Expr \MethodCall (
169
- var: $ parameter ['value ' ],
170
- name: new Node \Name ('format ' ),
171
- args: [
172
- new Node \Arg (
173
- value: new Node \Scalar \String_ ('YYYY-MM-DD HH:MI:SS ' )
174
- ),
175
- ],
160
+ if (\array_key_exists ('iterable ' , $ parameter ) && true === $ parameter ['iterable ' ]) {
161
+ yield new Node \Stmt \Foreach_ (
162
+ expr: $ parameter ['value ' ],
163
+ valueVar: new Node \Expr \Variable ('value ' ),
164
+ subNodes: [
165
+ 'keyVar ' => new Node \Expr \Variable ('key ' ),
166
+ 'stmts ' => [
167
+ $ this ->compileParameters (
168
+ new Node \Arg (
169
+ new Node \Expr \BinaryOp \Concat (
170
+ new Node \Scalar \String_ ($ key .'_ ' ),
171
+ new Node \Expr \Variable ('key ' ),
172
+ )
176
173
),
174
+ [
175
+ 'type ' => $ parameter ['type ' ],
176
+ 'value ' => new Node \Expr \Variable ('value ' ),
177
+ ]
177
178
),
178
- $ this ->compileParameterType ($ parameter ),
179
179
],
180
- ),
181
- ),
182
- 'date ' => new Node \Stmt \Expression (
183
- new Node \Expr \MethodCall (
184
- var: new Node \Expr \Variable ('statement ' ),
185
- name: new Node \Identifier ('bindValue ' ),
186
- args: [
187
- new Node \Arg (
188
- \is_string ($ key ) ? new Node \Scalar \Encapsed (
189
- [
190
- new Node \Scalar \EncapsedStringPart (': ' ),
191
- new Node \Scalar \EncapsedStringPart ($ key ),
192
- ]
193
- ) : new Node \Scalar \LNumber ($ key )
194
- ),
195
- new Node \Arg (
196
- value: new Node \Expr \MethodCall (
197
- var: $ parameter ['value ' ],
198
- name: new Node \Name ('format ' ),
199
- args: [
200
- new Node \Arg (
201
- value: new Node \Scalar \String_ ('YYYY-MM-DD ' )
202
- ),
203
- ],
204
- ),
180
+ ]
181
+ );
182
+ } else {
183
+ yield $ this ->compileParameters ($ key , $ parameter );
184
+ }
185
+ }
186
+ }
187
+
188
+ public function compileParameters (int |string |Node \Arg $ key , array $ parameter ): Node \Stmt \Expression
189
+ {
190
+ return match ($ parameter ['type ' ]) {
191
+ 'datetime ' => new Node \Stmt \Expression (
192
+ new Node \Expr \MethodCall (
193
+ var: new Node \Expr \Variable ('statement ' ),
194
+ name: new Node \Identifier ('bindValue ' ),
195
+ args: [
196
+ $ this ->compileParameterKey ($ key ),
197
+ new Node \Arg (
198
+ value: new Node \Expr \MethodCall (
199
+ var: $ parameter ['value ' ],
200
+ name: new Node \Name ('format ' ),
201
+ args: [
202
+ new Node \Arg (
203
+ value: new Node \Scalar \String_ ('YYYY-MM-DD HH:MI:SS ' )
204
+ ),
205
+ ],
205
206
),
206
- $ this -> compileParameterType ( $ parameter ),
207
- ] ,
208
- ) ,
207
+ ),
208
+ $ this -> compileParameterType ( $ parameter ) ,
209
+ ] ,
209
210
),
210
- 'json ' => new Node \Stmt \Expression (
211
- new Node \Expr \MethodCall (
212
- var: new Node \Expr \Variable ('statement ' ),
213
- name: new Node \Identifier ('bindValue ' ),
214
- args: [
215
- new Node \Arg (
216
- \is_string ($ key ) ? new Node \Scalar \Encapsed (
217
- [
218
- new Node \Scalar \EncapsedStringPart (': ' ),
219
- new Node \Scalar \EncapsedStringPart ($ key ),
220
- ]
221
- ) : new Node \Scalar \LNumber ($ key )
222
- ),
223
- new Node \Arg (
224
- new Node \Expr \FuncCall (
225
- name: new Node \Name ('json_encode ' ),
226
- args: [
227
- new Node \Arg (
228
- value: $ parameter ['value ' ]
229
- ),
230
- ],
231
- ),
211
+ ),
212
+ 'date ' => new Node \Stmt \Expression (
213
+ new Node \Expr \MethodCall (
214
+ var: new Node \Expr \Variable ('statement ' ),
215
+ name: new Node \Identifier ('bindValue ' ),
216
+ args: [
217
+ $ this ->compileParameterKey ($ key ),
218
+ new Node \Arg (
219
+ value: new Node \Expr \MethodCall (
220
+ var: $ parameter ['value ' ],
221
+ name: new Node \Name ('format ' ),
222
+ args: [
223
+ new Node \Arg (
224
+ value: new Node \Scalar \String_ ('YYYY-MM-DD ' )
225
+ ),
226
+ ],
232
227
),
233
- $ this -> compileParameterType ( $ parameter ),
234
- ] ,
235
- ) ,
228
+ ),
229
+ $ this -> compileParameterType ( $ parameter ) ,
230
+ ] ,
236
231
),
237
- default => new Node \ Stmt \ Expression (
238
- new Node \Expr \ MethodCall (
239
- var: new Node \Expr \Variable ( ' statement ' ),
240
- name : new Node \Identifier ( ' bindValue ' ),
241
- args: [
242
- new Node \ Arg (
243
- \is_string ($ key ) ? new Node \ Scalar \ Encapsed (
244
- [
245
- new Node \Scalar \ EncapsedStringPart ( ' : ' ),
246
- new Node \Scalar \ EncapsedStringPart ( $ key ),
247
- ]
248
- ) : new Node \Scalar \ LNumber ( $ key )
249
- ),
250
- new Node \ Arg (
251
- $ parameter [ ' value ' ]
232
+ ),
233
+ ' json ' => new Node \Stmt \ Expression (
234
+ new Node \Expr \MethodCall (
235
+ var : new Node \Expr \ Variable ( ' statement ' ),
236
+ name: new Node \ Identifier ( ' bindValue ' ),
237
+ args: [
238
+ $ this -> compileParameterKey ($ key ),
239
+ new Node \ Arg (
240
+ new Node \Expr \ FuncCall (
241
+ name: new Node \Name ( ' json_encode ' ),
242
+ args: [
243
+ new Node \Arg (
244
+ value: $ parameter [ ' value ' ]
245
+ ),
246
+ ],
252
247
),
253
- $ this -> compileParameterType ( $ parameter ),
254
- ] ,
255
- ) ,
248
+ ),
249
+ $ this -> compileParameterType ( $ parameter ) ,
250
+ ] ,
256
251
),
257
- };
252
+ ),
253
+ default => new Node \Stmt \Expression (
254
+ new Node \Expr \MethodCall (
255
+ var: new Node \Expr \Variable ('statement ' ),
256
+ name: new Node \Identifier ('bindValue ' ),
257
+ args: [
258
+ $ this ->compileParameterKey ($ key ),
259
+ new Node \Arg (
260
+ $ parameter ['value ' ]
261
+ ),
262
+ $ this ->compileParameterType ($ parameter ),
263
+ ],
264
+ ),
265
+ ),
266
+ };
267
+ }
268
+
269
+ private function compileParameterKey (int |string |Node \Arg $ key ): Node \Arg
270
+ {
271
+ if (\is_string ($ key )) {
272
+ return new Node \Arg (
273
+ new Node \Scalar \Encapsed ([
274
+ new Node \Scalar \EncapsedStringPart (': ' ),
275
+ new Node \Scalar \EncapsedStringPart ($ key ),
276
+ ])
277
+ );
258
278
}
279
+ if ($ key instanceof Node \Arg) {
280
+ return $ key ;
281
+ }
282
+
283
+ return new Node \Arg (
284
+ new Node \Scalar \LNumber ($ key )
285
+ );
259
286
}
260
287
261
288
private function compileParameterType (array $ parameter ): Node \Arg
0 commit comments