Clover icon

core 1.0-SNAPSHOT

  1. Project Clover database Wed Nov 12 2025 05:07:35 UTC
  2. Package guru.mikelue.foxglove.jdbc

File ColumnSettingSteps.java

 

Coverage histogram

../../../../img/srcFileCovDistChart6.png
80% of files have more coverage

Code metrics

0
22
11
7
422
106
11
0.5
2
1.57
1

Classes

Class Line # Actions
ColumnSettingSteps 19 0 - 0 0
-1.0 -
ColumnSettingSteps.ColumnSimpleStep 28 4 0% 2 3
0.550%
ColumnSettingSteps.ColumnFromStep 113 0 - 0 0
-1.0 -
ColumnSettingSteps.ReferenceSettingStep 148 0 - 0 0
-1.0 -
ColumnSettingSteps.ReferenceSettingStep.CardinalityStep 152 0 - 0 0
-1.0 -
ColumnSettingSteps.KeyOfIntSettingStep 199 10 0% 7 10
0.411764741.2%
ColumnSettingSteps.CartesianProductSettingStep 367 8 0% 2 3
0.770%
 

Contributing tests

This file is covered by 28 tests. .

Source view

1    package guru.mikelue.foxglove.jdbc;
2   
3    import java.util.ArrayList;
4    import java.util.List;
5    import java.util.function.Function;
6    import java.util.stream.LongStream;
7    import java.util.stream.Stream;
8   
9    import org.apache.commons.lang3.Validate;
10   
11    import guru.mikelue.foxglove.functional.*;
12    import guru.mikelue.foxglove.jdbc.ColumnSettingSteps.ColumnFromStep;
13    import guru.mikelue.foxglove.jdbc.JdbcTableFacet.Builder;
14    import guru.mikelue.foxglove.setting.ColumnConfig;
15   
16    /**
17    * Aggregation of steps for column setting steps.
18    */
 
19    public interface ColumnSettingSteps {
20    /**
21    * The step to configure column.
22    *
23    * <p>
24    * This interface supports same methods as {@link ColumnConfig}.
25    *
26    * @param <T> The type of value generated for the column
27    */
 
28    public interface ColumnSimpleStep<T> extends ColumnConfig<T, Builder> {
29    /**
30    * Uses a function that converts row index to value.
31    *
32    * @param rowIndexToValue The function that converts row index to value
33    *
34    * @return The builder for {@link JdbcTableFacet}
35    */
36    Builder forRow(RowIndexToValue<? extends T> rowIndexToValue);
37   
38    /**
39    * Uses a fixed value for the column.
40    *
41    * @param fixedValue The fixed value
42    *
43    * @return The builder for {@link JdbcTableFacet}
44    */
45    Builder fixed(T fixedValue);
46   
47    /**
48    * Configures the column to get values from another table's column.
49    *
50    * <p>
51    * This is differ from {@link JdbcTableFacet.Builder#referencing(String)} in that
52    * the number of rows is not affected by this configuration.
53    *
54    * @param referencedTable The referenced table facet
55    * @param referencedColumn The column name of referenced in referenced table
56    *
57    * @return The step to configure column from another table
58    */
59    ColumnFromStep<T> from(JdbcTableFacet referencedTable, String referencedColumn);
60   
61    /**
62    * Generates data by round-robin of values.
63    *
64    * @param values The values
65    *
66    * @return The builder for {@link JdbcTableFacet}
67    *
68    * @see #roundRobin(List)
69    */
70    @SuppressWarnings("unchecked")
71    Builder roundRobin(T... values);
72   
73    /**
74    * Generates data by round-robin of values.
75    *
76    * @param domain The stream of values
77    *
78    * @return The builder for {@link JdbcTableFacet}
79    *
80    * @see #roundRobin(List)
81    */
 
82  0 toggle @SuppressWarnings("unchecked")
83    default Builder roundRobin(Stream<? extends T> domain)
84    {
85  0 Validate.notNull(domain, "Domain stream must not be null");
86   
87  0 return roundRobin((T[])domain.toArray());
88    };
89   
90    /**
91    * Generates data by round-robin of values.
92    *
93    * @param values The list of values
94    *
95    * @return The builder for {@link JdbcTableFacet}
96    *
97    * @see #roundRobin(Object...)
98    */
 
99  4 toggle @SuppressWarnings("unchecked")
100    default Builder roundRobin(List<? extends T> values)
101    {
102  4 Validate.notNull(values, "Domain stream must not be null");
103   
104  4 return roundRobin((T[])values.toArray());
105    }
106    }
107   
108    /**
109    * The step to configure column from another table.
110    *
111    * @param <T> The type of value generated for the column
112    */
 
113    public interface ColumnFromStep<T> {
114    /**
115    * Transforms the domain of referenced column to another domain values.
116    *
117    * @param <V> The type to which the value of referencing column is converted
118    * @param domainConverter The function to convert stream of values
119    *
120    * @return The step to configure column from another table
121    */
122    <V> ColumnFromStep<V> transformDomain(Function<? super Stream<T>, ? extends Stream<V>> domainConverter);
123   
124    /**
125    * Uses round-robin strategy to assign values from referenced column of another table.
126    *
127    * @return The builder for {@link JdbcTableFacet}
128    *
129    * @see #random()
130    */
131    Builder roundRobin();
132   
133    /**
134    * Uses random choosing over values from referenced column of another table.
135    *
136    * @return The builder for {@link JdbcTableFacet}
137    *
138    * @see #roundRobin()
139    */
140    Builder random();
141    }
142   
143    /**
144    * The step to configure reference column.
145    *
146    * @param <T> The type of value generated for the column
147    */
 
148    public interface ReferenceSettingStep<T> {
149    /**
150    * The step to configure cardinality of reference.
151    */
 
152    public interface CardinalityStep {
153    /**
154    * Sets the number of rows in child table per one row in parent table.
155    *
156    * @param numberOfChildrenPerParent The number of rows in child table. At least 1.
157    *
158    * @return The builder for {@link JdbcTableFacet}
159    */
160    Builder cardinality(int numberOfChildrenPerParent);
161   
162    /**
163    * Makes the number of rows is generated randomly in child table per one row in parent table.
164    *
165    * @param min The minimum number of rows in child table, At least 0.
166    * @param max The maximum number of rows in child table
167    *
168    * @return The builder for {@link JdbcTableFacet}
169    */
170    Builder cardinality(int min, int max);
171    }
172   
173    /**
174    * Assigns the key column explicitly.
175    *
176    * @param parentTable The parent table facet
177    * @param referencedColumn The column name of referenced in parent table
178    *
179    * @return The next step to configure reference column
180    */
181    CardinalityStep parent(JdbcTableFacet parentTable, String referencedColumn);
182    }
183   
184    /**
185    * The step used to limit the number of rows by
186    * bounding integral value for a column,
187    *
188    * <p>
189    * <em>This interface is not about uniqueness,
190    * is about to assign number of rows.</em>
191    *
192    * If what you need only integral sequence for a column,
193    * just use {@link Builder#column(String)} with {@link Int4SequenceSupplier}, etc.
194    *
195    * @see SequenceSupplier
196    * @see Int4SequenceSupplier
197    * @see Int8SequenceSupplier
198    */
 
199    public interface KeyOfIntSettingStep {
200    /**
201    * Sets the range of values for key column(starts with 1, step 1).
202    *
203    * @param end The end value (exclusive)
204    *
205    * @return The builder for {@link JdbcTableFacet}
206    *
207    * @see #range(long, long)
208    * @see #limit(int)
209    */
 
210  0 toggle default Builder range(long end)
211    {
212  0 return range(1, end, 1);
213    }
214   
215    /**
216    * Sets the range of values for key column(with step 1).
217    *
218    * @param start The start value (inclusive)
219    * @param end The end value (exclusive)
220    *
221    * @return The builder for {@link JdbcTableFacet}
222    *
223    * @see #range(long, long, int)
224    * @see #limit(long, int)
225    */
 
226  4 toggle default Builder range(long start, long end)
227    {
228  4 return range(start, end, 1);
229    }
230   
231    /**
232    * Sets the range of values for key column.
233    *
234    * @param start The start value (inclusive)
235    * @param end The end value (exclusive)
236    * @param step The step value
237    *
238    * @return The builder for {@link JdbcTableFacet}
239    *
240    * @see #range(long)
241    * @see #range(long, long)
242    * @see #limit(long, int, int)
243    */
244    Builder range(long start, long end, int step);
245   
246    /**
247    * Sets the limit number of values can be generated for key column(starts with 1, steps with 1).
248    *
249    * @param number The number of values can be generated
250    *
251    * @return The builder for {@link JdbcTableFacet}
252    *
253    * @see #limit(long, int)
254    * @see #range(long)
255    */
 
256  0 toggle default Builder limit(int number)
257    {
258  0 return limit(1, number, 1);
259    }
260   
261    /**
262    * Sets the limit number of values can be generated for key column(steps with 1).
263    *
264    * @param start The start value
265    * @param number The number of values can be generated
266    *
267    * @return The builder for {@link JdbcTableFacet}
268    *
269    * @see #limit(long, int, int)
270    * @see #range(long, long)
271    */
 
272  17 toggle default Builder limit(long start, int number)
273    {
274  17 return limit(start, number, 1);
275    }
276   
277    /**
278    * Sets the limit number of values can be generated for key column.
279    *
280    * @param start The start value
281    * @param number The number of values can be generated
282    * @param step The step value
283    *
284    * @return The builder for {@link JdbcTableFacet}
285    *
286    * @see #limit(int)
287    * @see #limit(long, int)
288    * @see #range(long, long, int)
289    */
290    Builder limit(long start, int number, int step);
291   
292    /**
293    * Sets the domain of numbers to be used for key column.
294    *
295    * @param domain The list of values
296    *
297    * @return The builder for {@link JdbcTableFacet}
298    *
299    * @see #range(long, long, int)
300    * @see #limit(long, int, int)
301    */
 
302  0 toggle default Builder domain(Stream<Long> domain)
303    {
304  0 Validate.notNull(domain, "Domain stream must not be null");
305   
306  0 return domain(
307    domain.mapToLong(Long::longValue)
308    .toArray()
309    );
310    }
311   
312    /**
313    * Sets the domain of numbers to be used for key column.
314    *
315    * @param domain The list of values
316    *
317    * @return The builder for {@link JdbcTableFacet}
318    *
319    * @see #range(long, long, int)
320    * @see #limit(long, int, int)
321    */
 
322  3 toggle default Builder domain(List<Long> domain)
323    {
324  3 Validate.noNullElements(domain, "Domain list must not have null element");
325   
326  3 return domain(
327    domain.stream().mapToLong(Long::longValue)
328    .toArray()
329    );
330    }
331   
332    /**
333    * Sets the set of number of values to be used for key column.
334    *
335    * @param domain The list of values
336    *
337    * @return The builder for {@link JdbcTableFacet}
338    *
339    * @see #range(long, long, int)
340    * @see #limit(long, int, int)
341    */
 
342  0 toggle default Builder domain(LongStream domain)
343    {
344  0 Validate.notNull(domain, "Domain stream must not be null");
345   
346  0 return domain(domain.toArray());
347    }
348   
349    /**
350    * Sets the set of number of values to be used for key column.
351    *
352    * @param domain The list of values
353    *
354    * @return The builder for {@link JdbcTableFacet}
355    *
356    * @see #range(long, long, int)
357    * @see #limit(long, int, int)
358    */
359    Builder domain(long[] domain);
360    }
361   
362    /**
363    * The step to configure Cartesian product for a column.
364    *
365    * @param <T> The type of value generated for the column
366    */
 
367    public interface CartesianProductSettingStep<T> {
368    /**
369    * Sets the domain of values for Cartesian product.
370    *
371    * @param values The values to use
372    *
373    * @return The builder for {@link JdbcTableFacet}
374    */
 
375  12 toggle @SuppressWarnings("unchecked")
376    default Builder domain(T... values)
377    {
378  12 Validate.notEmpty(values, "Rest values must not have null element");
379  12 Validate.noNullElements(values, "Rest values must not have null element");
380   
381  12 var allValues = new ArrayList<T>(values.length);
382  12 for (var value : values) {
383  31 allValues.add(value);
384    }
385   
386  12 return domain(allValues);
387    }
388   
389    /**
390    * Sets the domain of values for Cartesian product.
391    *
392    * @param domain The stream of values
393    *
394    * @return The builder for {@link JdbcTableFacet}
395    */
 
396  0 toggle default Builder domain(Stream<? extends T> domain)
397    {
398  0 Validate.notNull(domain, "Domain stream must not be null");
399   
400  0 return domain(domain.toList());
401    }
402   
403    /**
404    * Sets the domain of values for Cartesian product.
405    *
406    * @param values The list of values
407    *
408    * @return The builder for {@link JdbcTableFacet}
409    */
410    Builder domain(List<? extends T> values);
411   
412    /**
413    * References values from column of another table's for Cartesian product.
414    *
415    * @param referencedTable The referenced table facet
416    * @param referencedColumn The column name of referenced in referenced table
417    *
418    * @return The builder for {@link JdbcTableFacet}
419    */
420    Builder referencing(JdbcTableFacet referencedTable, String referencedColumn);
421    }
422    }
  • Report generated by OpenClover v 4.5.2 on Wed Nov 12 2025 05:07:53 UTC using coverage data from Wed Nov 12 2025 05:07:50 UTC.
  • OpenClover is free and open-source software.