leeonky / test-charm-java / 156

Committed 20 Mar 2025 01:53PM UTC coverage: 74.243% (-0.2%) from 74.475%

Build # 156

Build Type

push

circleci

Committed by

leeonky

Commit Message

Refactor

Run Details

14 of 15 new or added lines in 12 files covered. (93.33%)

126 existing lines in 29 files now uncovered.

7947 of 10704 relevant lines covered (74.24%)

0.74 hits per line

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

94.83

/DAL-extension-jdbc/src/main/java/com/github/leeonky/dal/extensions/jdbc/DataBase.java

package com.github.leeonky.dal.extensions.jdbc;

import com.github.leeonky.dal.runtime.DalRuntimeException;
import com.github.leeonky.dal.runtime.ProxyObject;
import com.github.leeonky.util.Sneaky;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.*;
import java.util.function.Supplier;

public class DataBase implements AutoCloseable, ProxyObject {
    public final Connection connection;
    public final DataBaseBuilder builder;
    public Set<String> queriedTables = new LinkedHashSet<>();

    public DataBase(Connection connection, DataBaseBuilder builder) {
        this.connection = connection;
        this.builder = builder;
    }

    public Set<String> allTableNames() {
        return new LinkedHashSet<String>() {{
            addAll(builder.tablesProvider().apply(Sneaky.get(connection::createStatement)));
            addAll(queriedTables);
        }};
    }

    public Table<?> table(String name) {
        queriedTables.add(name);
        return new Table<>(name);
    }

    public String getUrl() {
        return Sneaky.get(() -> connection.getMetaData().getURL());
    }

    @Override
    public void close() throws Exception {
        connection.close();
    }

    @Override
    public Object getValue(Object property) {
        return table((String) property);
    }

    @Override
    public Set<?> getPropertyNames() {
        return allTableNames();
    }

    public class Table<T extends Table<T>> implements Iterable<Row<T>>, CanWhere<T> {
        private final String name;
        protected final Query query;

        public Table(String name) {
            this(name, new Query(name, name + ".*"));
        }

        private Table(String name, Query query) {
            this.name = name;
            this.query = query;
        }

        public String name() {
            return name;
        }

        @Override
        public Iterator<DataBase.Row<T>> iterator() {
            return Sneaky.get(() -> query(query()));
        }

        @SuppressWarnings("unchecked")
        protected T createInstance(Query query) {
            return (T) new Table<>(name, query);
        }

        protected Iterator<DataBase.Row<T>> query(Query query) throws SQLException {
            ResultSet resultSet = query.execute(connection);
            return new Iterator<DataBase.Row<T>>() {
                private final Set<String> columns = new LinkedHashSet<String>() {{
                    ResultSetMetaData metaData = resultSet.getMetaData();
                    int columnCount = metaData.getColumnCount();
                    for (int i = 1; i <= columnCount; ++i)
                        add(metaData.getColumnLabel(i).toLowerCase());
                }};

                @Override
                public boolean hasNext() {
                    return Sneaky.get(resultSet::next);
                }

                @Override
                public DataBase.Row<T> next() {
                    return Sneaky.get(this::getRow);
                }

                @SuppressWarnings("unchecked")
                private DataBase.Row<T> getRow() throws SQLException {
                    return new Row<>((T) Table.this, new LinkedHashMap<String, Object>() {{
                        for (String column : columns)
                            put(column, resultSet.getObject(column));
                    }});
                }
            };
        }

        public Query query() {
            return query;
        }

        public T select(String select) {
            return createInstance(query.select(select));
        }

        @Override
        public T where(String clause) {
            return createInstance(query.where(clause));
        }

        public T where(String clause, Map<String, Object> parameters) {
            return createInstance(query.where(clause).parameters(parameters));
        }
    }

    public class Row<T extends Table<T>> implements ProxyObject {
        protected final T table;
        protected Map<String, Object> data;

        public Row(T table, Map<String, Object> data) {
            this.table = table;
            this.data = data;
        }

        public Object value(String column) {
            if (data().containsKey(column))
                return data().get(column);
            return builder.callRowMethod(this, column);
        }

        public Set<String> columns() {
            return data().keySet();
        }

        public Map<String, Object> data() {
            return data;
        }

        public boolean empty() {
            return data() == null;
        }

        public LinkedRow belongsTo(String parentTable) {
            return join(parentTable).asParent().exactlyOne();
        }

        public LinkedTable join(String anotherTable) {
            return new LinkedTable(this, anotherTable);
        }

        public LinkedRow hasOne(String childTableOrManyToMany) {
            return join(childTableOrManyToMany).asChildren().exactlyOne();
        }

        public LinkedTable hasMany(String childTableOrManyToMany) {
            return join(childTableOrManyToMany).asChildren();
        }

        public T table() {
            return table;
        }

        @Override
        public Object getValue(Object property) {
            return value((String) property);
        }

        @Override
        public Set<?> getPropertyNames() {
            return columns();
        }

        @Override
        public boolean isNull() {
            return empty();
        }
    }

    public class LinkedTable extends Table<LinkedTable> implements Association<LinkedTable> {
        protected final Row<? extends Table<?>> row;

        public LinkedTable(Row<? extends Table<?>> row, String name) {
            super(name);
            this.row = row;
            query.parameters().putAll(row.table().query().parameters());
            query.parameters().putAll(row.data());
        }

        public LinkedTable(Row<? extends Table<?>> row, String name, Query query) {
            super(name, query);
            this.row = row;
        }

        public LinkedTable defaultParameterColumn(String parameterColumn) {
            return createInstance(query.defaultParameterColumn(parameterColumn));
        }

        public LinkedTable defaultLinkColumn(String linkColumn) {
            return createInstance(query.defaultLinkColumn(linkColumn));
        }

        @Override
        public LinkedTable on(String condition) {
            return createInstance(query.on(condition));
        }

        @Override
        protected LinkedTable createInstance(Query query) {
            return new LinkedTable(row, name(), query);
        }

        public DataBase.LinkedRow exactlyOne() {
            return new DataBase.LinkedRow(this, () -> {
                Iterator<Row<LinkedTable>> iterator = iterator();
                if (iterator.hasNext()) {
                    DataBase.Row<LinkedTable> row = iterator.next();
                    if (iterator.hasNext())
                        throw new DalRuntimeException("Result set has multiple records");
                    return row.data();
                }
                return null;
            });
        }

        public LinkedTable asParent() {
            return defaultLinkColumn(builder.resolveReferencedColumn(this, row.table()))
                    .defaultParameterColumn(builder.resolveJoinColumn(this, row.table()));
        }

        public LinkedTable asChildren() {
            return defaultLinkColumn(builder.resolveJoinColumn(row.table(), this))
                    .defaultParameterColumn(builder.resolveReferencedColumn(row.table(), this));
        }

        @Override
        public LinkedTable through(String table) {
            LinkedTable throughTable = row.join(table).asChildren();
            String joinColumn = builder.resolveJoinColumn(this, throughTable);
            return new LinkedThroughTable(this, throughTable.select(joinColumn));
        }

        @Override
        public LinkedTable through(String table, String joinColumn) {
            return new LinkedThroughTable(this, row.join(table).asChildren().select(joinColumn));
        }
    }

    public class LinkedThroughTable extends LinkedTable {
        private final LinkedTable thoughTable;
        private final String referencedColumn;

        public LinkedThroughTable(LinkedTable linkedTable, LinkedTable thoughTable) {
            super(linkedTable.row, linkedTable.name(), linkedTable.query().on(null));
            this.thoughTable = thoughTable;
            referencedColumn = linkedTable.query().linkColumn() == null ?
                    builder.resolveReferencedColumn(linkedTable, thoughTable) : linkedTable.query().linkColumn();
        }

        public LinkedThroughTable(LinkedTable thoughTable, String referencedColumn,
                                  Row<? extends Table<?>> row, String name, Query query) {
            super(row, name, query);
            this.thoughTable = thoughTable;
            this.referencedColumn = referencedColumn;
        }

        @Override
        protected Iterator<Row<LinkedTable>> query(Query query) throws SQLException {
            return super.query(query.where(String.format("%s in (%s)", referencedColumn, thoughTable.query().buildSql())));
        }

        @Override
        protected LinkedTable createInstance(Query query) {
            return new LinkedThroughTable(thoughTable, referencedColumn, row, name(), query);
        }

        @Override
        public LinkedTable on(String condition) {
            return new LinkedThroughTable(thoughTable.on(condition), referencedColumn, row, name(), query);
        }
    }

    public class LinkedRow extends Row<LinkedTable> implements CanWhere<LinkedRow>, Association<LinkedRow> {
        protected Supplier<Map<String, Object>> query;

        public LinkedRow(LinkedTable table, Supplier<Map<String, Object>> query) {
            super(table, null);
            this.query = query;
        }

        @Override
        public Map<String, Object> data() {
            if (data == null)
                data = query.get();
            return super.data();
        }

        @Override
        public LinkedRow where(String clause) {
            return table().where(clause).exactlyOne();
        }

        @Override
        public LinkedRow on(String condition) {
            return table().on(condition).exactlyOne();
        }

        @Override
        public LinkedRow through(String table) {
            return table().through(table).exactlyOne();
        }

        @Override
        public LinkedRow through(String table, String joinColumn) {
            return table().through(table, joinColumn).exactlyOne();
        }
    }
}

1	package com.github.leeonky.dal.extensions.jdbc;
2
3	import com.github.leeonky.dal.runtime.DalRuntimeException;
4	import com.github.leeonky.dal.runtime.ProxyObject;
5	import com.github.leeonky.util.Sneaky;
6
7	import java.sql.Connection;
8	import java.sql.ResultSet;
9	import java.sql.ResultSetMetaData;
10	import java.sql.SQLException;
11	import java.util.*;
12	import java.util.function.Supplier;
13
14	public class DataBase implements AutoCloseable, ProxyObject {
15	public final Connection connection;
16	public final DataBaseBuilder builder;
17	public Set<String> queriedTables = new LinkedHashSet<>();	1✔
18
19	public DataBase(Connection connection, DataBaseBuilder builder) {	1✔
20	this.connection = connection;	1✔
21	this.builder = builder;	1✔
22	}	1✔
23
24	public Set<String> allTableNames() {
25	return new LinkedHashSet<String>() {{	1✔
26	addAll(builder.tablesProvider().apply(Sneaky.get(connection::createStatement)));	1✔
27	addAll(queriedTables);	1✔
28	}};	1✔
29	}
30
31	public Table<?> table(String name) {
32	queriedTables.add(name);	1✔
33	return new Table<>(name);	1✔
34	}
35
36	public String getUrl() {
37	return Sneaky.get(() -> connection.getMetaData().getURL());	1✔
38	}
39
40	@Override
41	public void close() throws Exception {
42	connection.close();	×
UNCOV 43	}	×
44
45	@Override
46	public Object getValue(Object property) {
47	return table((String) property);	1✔
48	}
49
50	@Override
51	public Set<?> getPropertyNames() {
52	return allTableNames();	1✔
53	}
54
55	public class Table<T extends Table<T>> implements Iterable<Row<T>>, CanWhere<T> {
56	private final String name;
57	protected final Query query;
58
59	public Table(String name) {
60	this(name, new Query(name, name + ".*"));	1✔
61	}	1✔
62
63	private Table(String name, Query query) {	1✔
64	this.name = name;	1✔
65	this.query = query;	1✔
66	}	1✔
67
68	public String name() {
69	return name;	1✔
70	}
71
72	@Override
73	public Iterator<DataBase.Row<T>> iterator() {
74	return Sneaky.get(() -> query(query()));	1✔
75	}
76
77	@SuppressWarnings("unchecked")
78	protected T createInstance(Query query) {
79	return (T) new Table<>(name, query);	1✔
80	}
81
82	protected Iterator<DataBase.Row<T>> query(Query query) throws SQLException {
83	ResultSet resultSet = query.execute(connection);	1✔
84	return new Iterator<DataBase.Row<T>>() {	1✔
85	private final Set<String> columns = new LinkedHashSet<String>() {{	1✔
86	ResultSetMetaData metaData = resultSet.getMetaData();	1✔
87	int columnCount = metaData.getColumnCount();	1✔
88	for (int i = 1; i <= columnCount; ++i)	1✔
89	add(metaData.getColumnLabel(i).toLowerCase());	1✔
90	}};	1✔
91
92	@Override
93	public boolean hasNext() {
94	return Sneaky.get(resultSet::next);	1✔
95	}
96
97	@Override
98	public DataBase.Row<T> next() {
99	return Sneaky.get(this::getRow);	1✔
100	}
101
102	@SuppressWarnings("unchecked")
103	private DataBase.Row<T> getRow() throws SQLException {
104	return new Row<>((T) Table.this, new LinkedHashMap<String, Object>() {{	1✔
105	for (String column : columns)	1✔
106	put(column, resultSet.getObject(column));	1✔
107	}});	1✔
108	}
109	};
110	}
111
112	public Query query() {
113	return query;	1✔
114	}
115
116	public T select(String select) {
117	return createInstance(query.select(select));	1✔
118	}
119
120	@Override
121	public T where(String clause) {
122	return createInstance(query.where(clause));	1✔
123	}
124
125	public T where(String clause, Map<String, Object> parameters) {
UNCOV 126	return createInstance(query.where(clause).parameters(parameters));	×
127	}
128	}
129
130	public class Row<T extends Table<T>> implements ProxyObject {
131	protected final T table;
132	protected Map<String, Object> data;
133
134	public Row(T table, Map<String, Object> data) {	1✔
135	this.table = table;	1✔
136	this.data = data;	1✔
137	}	1✔
138
139	public Object value(String column) {
140	if (data().containsKey(column))	1✔
141	return data().get(column);	1✔
142	return builder.callRowMethod(this, column);	1✔
143	}
144
145	public Set<String> columns() {
146	return data().keySet();	1✔
147	}
148
149	public Map<String, Object> data() {
150	return data;	1✔
151	}
152
153	public boolean empty() {
154	return data() == null;	1✔
155	}
156
157	public LinkedRow belongsTo(String parentTable) {
158	return join(parentTable).asParent().exactlyOne();	1✔
159	}
160
161	public LinkedTable join(String anotherTable) {
162	return new LinkedTable(this, anotherTable);	1✔
163	}
164
165	public LinkedRow hasOne(String childTableOrManyToMany) {
166	return join(childTableOrManyToMany).asChildren().exactlyOne();	1✔
167	}
168
169	public LinkedTable hasMany(String childTableOrManyToMany) {
170	return join(childTableOrManyToMany).asChildren();	1✔
171	}
172
173	public T table() {
174	return table;	1✔
175	}
176
177	@Override
178	public Object getValue(Object property) {
179	return value((String) property);	1✔
180	}
181
182	@Override
183	public Set<?> getPropertyNames() {
UNCOV 184	return columns();	×
185	}
186
187	@Override
188	public boolean isNull() {
189	return empty();	1✔
190	}
191	}
192
193	public class LinkedTable extends Table<LinkedTable> implements Association<LinkedTable> {
194	protected final Row<? extends Table<?>> row;
195
196	public LinkedTable(Row<? extends Table<?>> row, String name) {	1✔
197	super(name);	1✔
198	this.row = row;	1✔
199	query.parameters().putAll(row.table().query().parameters());	1✔
200	query.parameters().putAll(row.data());	1✔
201	}	1✔
202
203	public LinkedTable(Row<? extends Table<?>> row, String name, Query query) {	1✔
204	super(name, query);	1✔
205	this.row = row;	1✔
206	}	1✔
207
208	public LinkedTable defaultParameterColumn(String parameterColumn) {
209	return createInstance(query.defaultParameterColumn(parameterColumn));	1✔
210	}
211
212	public LinkedTable defaultLinkColumn(String linkColumn) {
213	return createInstance(query.defaultLinkColumn(linkColumn));	1✔
214	}
215
216	@Override
217	public LinkedTable on(String condition) {
218	return createInstance(query.on(condition));	1✔
219	}
220
221	@Override
222	protected LinkedTable createInstance(Query query) {
223	return new LinkedTable(row, name(), query);	1✔
224	}
225
226	public DataBase.LinkedRow exactlyOne() {
227	return new DataBase.LinkedRow(this, () -> {	1✔
228	Iterator<Row<LinkedTable>> iterator = iterator();	1✔
229	if (iterator.hasNext()) {	1✔
230	DataBase.Row<LinkedTable> row = iterator.next();	1✔
231	if (iterator.hasNext())	1✔
232	throw new DalRuntimeException("Result set has multiple records");	1✔
233	return row.data();	1✔
234	}
235	return null;	1✔
236	});
237	}
238
239	public LinkedTable asParent() {
240	return defaultLinkColumn(builder.resolveReferencedColumn(this, row.table()))	1✔
241	.defaultParameterColumn(builder.resolveJoinColumn(this, row.table()));	1✔
242	}
243
244	public LinkedTable asChildren() {
245	return defaultLinkColumn(builder.resolveJoinColumn(row.table(), this))	1✔
246	.defaultParameterColumn(builder.resolveReferencedColumn(row.table(), this));	1✔
247	}
248
249	@Override
250	public LinkedTable through(String table) {
251	LinkedTable throughTable = row.join(table).asChildren();	1✔
252	String joinColumn = builder.resolveJoinColumn(this, throughTable);	1✔
253	return new LinkedThroughTable(this, throughTable.select(joinColumn));	1✔
254	}
255
256	@Override
257	public LinkedTable through(String table, String joinColumn) {
258	return new LinkedThroughTable(this, row.join(table).asChildren().select(joinColumn));	1✔
259	}
260	}
261
262	public class LinkedThroughTable extends LinkedTable {
263	private final LinkedTable thoughTable;
264	private final String referencedColumn;
265
266	public LinkedThroughTable(LinkedTable linkedTable, LinkedTable thoughTable) {	1✔
267	super(linkedTable.row, linkedTable.name(), linkedTable.query().on(null));	1✔
268	this.thoughTable = thoughTable;	1✔
269	referencedColumn = linkedTable.query().linkColumn() == null ?	1✔
270	builder.resolveReferencedColumn(linkedTable, thoughTable) : linkedTable.query().linkColumn();	1✔
271	}	1✔
272
273	public LinkedThroughTable(LinkedTable thoughTable, String referencedColumn,
274	Row<? extends Table<?>> row, String name, Query query) {	1✔
275	super(row, name, query);	1✔
276	this.thoughTable = thoughTable;	1✔
277	this.referencedColumn = referencedColumn;	1✔
278	}	1✔
279
280	@Override
281	protected Iterator<Row<LinkedTable>> query(Query query) throws SQLException {
282	return super.query(query.where(String.format("%s in (%s)", referencedColumn, thoughTable.query().buildSql())));	1✔
283	}
284
285	@Override
286	protected LinkedTable createInstance(Query query) {
UNCOV 287	return new LinkedThroughTable(thoughTable, referencedColumn, row, name(), query);	×
288	}
289
290	@Override
291	public LinkedTable on(String condition) {
292	return new LinkedThroughTable(thoughTable.on(condition), referencedColumn, row, name(), query);	1✔
293	}
294	}
295
296	public class LinkedRow extends Row<LinkedTable> implements CanWhere<LinkedRow>, Association<LinkedRow> {
297	protected Supplier<Map<String, Object>> query;
298
299	public LinkedRow(LinkedTable table, Supplier<Map<String, Object>> query) {	1✔
300	super(table, null);	1✔
301	this.query = query;	1✔
302	}	1✔
303
304	@Override
305	public Map<String, Object> data() {
306	if (data == null)	1✔
307	data = query.get();	1✔
308	return super.data();	1✔
309	}
310
311	@Override
312	public LinkedRow where(String clause) {
313	return table().where(clause).exactlyOne();	1✔
314	}
315
316	@Override
317	public LinkedRow on(String condition) {
318	return table().on(condition).exactlyOne();	1✔
319	}
320
321	@Override
322	public LinkedRow through(String table) {
323	return table().through(table).exactlyOne();	1✔
324	}
325
326	@Override
327	public LinkedRow through(String table, String joinColumn) {
UNCOV 328	return table().through(table, joinColumn).exactlyOne();	×
329	}
330	}
331	}

leeonky / test-charm-java / 156

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