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

File TupleAccessorImpl.java

 

Coverage histogram

../../../../img/srcFileCovDistChart8.png
75% of files have more coverage

Code metrics

2
31
10
2
144
115
11
0.35
3.1
5
1.1

Classes

Class Line # Actions
TupleAccessorImpl 15 26 0% 9 11
0.694444469.4%
TupleAccessorImpl.TupleSchema 19 5 0% 2 0
1.0100%
 

Contributing tests

This file is covered by 60 tests. .

Source view

1    package guru.mikelue.foxglove.jdbc;
2   
3    import java.util.*;
4   
5    import org.apache.commons.lang3.Validate;
6    import org.apache.commons.lang3.builder.ToStringBuilder;
7   
8    import guru.mikelue.foxglove.ColumnMeta;
9    import guru.mikelue.foxglove.TupleAccessor;
10   
11    import static java.util.Collections.unmodifiableMap;
12    import static org.apache.commons.lang3.StringUtils.trimToEmpty;
13    import static org.apache.commons.lang3.builder.ToStringStyle.NO_CLASS_NAME_STYLE;
14   
 
15    class TupleAccessorImpl implements TupleAccessor {
16    /**
17    * Cached mapping between column name and its metadata.
18    */
 
19    static class TupleSchema {
20    private final Map<String, ColumnMeta> nameMappingOfColumns;
21   
 
22  246 toggle TupleSchema(Collection<ColumnMeta> columns)
23    {
24  246 var newMap = new HashMap<String, ColumnMeta>(columns.size());
25   
26  246 for (var columnMeta: columns) {
27  957 newMap.put(columnMeta.name().toLowerCase(), columnMeta);
28    }
29   
30  246 nameMappingOfColumns = unmodifiableMap(newMap);
31    }
32   
 
33  2772 toggle TupleAccessorImpl createTupleAccessor(
34    Map<ColumnMeta, Object> tuple,
35    int tupleIndex
36    ) {
37  2772 return new TupleAccessorImpl(this, tuple, tupleIndex);
38    }
39    }
40   
41    private final Map<String, Object> nameMappingOfValues;
42    private final Map<String, ColumnMeta> nameMappingOfColumns;
43    private final int tupleIndex;
44   
 
45  2772 toggle private TupleAccessorImpl(
46    TupleSchema tupleSchema, Map<ColumnMeta, Object> tuple,
47    int tupleIndex
48    ) {
49  2772 this.tupleIndex = tupleIndex;
50   
51  2772 nameMappingOfValues = new LinkedHashMap<String, Object>(tuple.size());
52  2772 nameMappingOfColumns = tupleSchema.nameMappingOfColumns;
53   
54  2772 for (var entry: tuple.entrySet()) {
55  13726 nameMappingOfValues.put(
56    entry.getKey().name().toLowerCase(),
57    entry.getValue()
58    );
59    }
60    }
61   
 
62  271 toggle @SuppressWarnings("unchecked")
63    @Override
64    public <T> T getValue(String name)
65    {
66  271 var safeName = trimToEmpty(name).toLowerCase();
67   
68  271 Validate.notEmpty(safeName, "Column name cannot be null or empty");
69  271 Validate.isTrue(
70    nameMappingOfValues.containsKey(safeName),
71    "Column name [%s] is not existing", safeName
72    );
73   
74  271 return (T)nameMappingOfValues.get(safeName);
75    }
76   
 
77  43 toggle @Override
78    public <T> void setValue(String name, T value)
79    {
80  43 var safeName = trimToEmpty(name).toLowerCase();
81   
82  43 Validate.notEmpty(safeName, "Column name cannot be null or empty");
83  43 Validate.isTrue(
84    nameMappingOfValues.containsKey(safeName),
85    "Column name [%s] is not existing", safeName
86    );
87   
88  43 nameMappingOfValues.put(safeName, value);
89    }
90   
 
91  0 toggle @Override
92    public List<ColumnMeta> getMetaOfColumns()
93    {
94  0 return Collections.unmodifiableList(
95    new ArrayList<>(nameMappingOfColumns.values())
96    );
97    }
98   
 
99  1359 toggle @Override
100    public Map<ColumnMeta, Object> asMap()
101    {
102  1359 var newMap = new LinkedHashMap<ColumnMeta, Object>(nameMappingOfValues.size());
103  1359 for (var columnMeta: nameMappingOfValues.keySet()) {
104  11556 newMap.put(
105    nameMappingOfColumns.get(columnMeta),
106    nameMappingOfValues.get(columnMeta)
107    );
108    }
109   
110  1359 return unmodifiableMap(newMap);
111    }
112   
 
113  0 toggle @Override
114    public int index()
115    {
116  0 return tupleIndex;
117    }
118   
 
119  258 toggle @Override
120    public boolean hasColumn(String name)
121    {
122  258 var safeName = trimToEmpty(name).toLowerCase();
123   
124  258 Validate.notEmpty(safeName, "Column name cannot be null or empty");
125  258 return nameMappingOfColumns.containsKey(safeName);
126    }
127   
 
128  0 toggle @Override
129    public String toString()
130    {
131  0 return new ToStringBuilder(this, NO_CLASS_NAME_STYLE)
132    .append("columns",
133    nameMappingOfValues.keySet().stream()
134    .map(columnName -> {
135  0 var value = nameMappingOfValues.get(columnName);
136  0 var meta = nameMappingOfColumns.get(columnName);
137  0 return "\"" + meta.name() + "\": " + (value != null ? value.toString() : "null");
138    })
139    .toList()
140    )
141    .append("index", tupleIndex)
142    .toString();
143    }
144    }