17073502945

Committed 19 Aug 2025 02:56PM UTC coverage: 68.2%. Remained the same

Build # 17073502945

Build Type

push

github

Committed by

torand

Commit Message

chore: adjust sonar cloud config to avoid noise

Run Details

299 of 598 branches covered (50.0%)

Branch coverage included in aggregate %.

1629 of 2229 relevant lines covered (73.08%)

3.97 hits per line

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

86.21

/src/main/java/io/github/torand/fastersql/expression/cases/SearchedCase.java

/*
 * Copyright (c) 2024-2025 Tore Eide Andersen
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.github.torand.fastersql.expression.cases;

import io.github.torand.fastersql.alias.ColumnAlias;
import io.github.torand.fastersql.expression.Expression;
import io.github.torand.fastersql.model.Column;
import io.github.torand.fastersql.projection.Projection;
import io.github.torand.fastersql.sql.Context;
import io.github.torand.fastersql.sql.Sql;

import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

import static io.github.torand.javacommons.contract.Requires.requireNonBlank;
import static io.github.torand.javacommons.contract.Requires.requireNonEmpty;
import static io.github.torand.javacommons.lang.StringHelper.nonBlank;
import static io.github.torand.javacommons.stream.StreamHelper.streamSafely;
import static java.util.Objects.nonNull;

/**
 * Implements a searched CASE expression.
 */
public class SearchedCase implements Expression {
    private final List<SearchedWhenThen> whenThenExpressions;
    private final Expression elseExpression;
    private final ColumnAlias alias;

    SearchedCase(List<SearchedWhenThen> whenThenExpressions, Expression elseExpression, String alias) {
        this.whenThenExpressions = requireNonEmpty(whenThenExpressions, "No when-then expressions specified");
        this.elseExpression = elseExpression;
        this.alias = nonBlank(alias) ? new ColumnAlias(alias) : defaultAlias();
    }

    // Sql

    @Override
    public String sql(Context context) {
        StringBuilder sql = new StringBuilder();
        sql.append("case ");
        streamSafely(whenThenExpressions).forEach(wt -> sql.append(wt.sql(context)).append(" "));
        if (nonNull(elseExpression)) {
            sql.append("else ").append(elseExpression.sql(context)).append(" ");
        }
        sql.append("end");
        return sql.toString();
    }

    @Override
    public Stream<Object> params(Context context) {
        return Stream.concat(
            streamSafely(whenThenExpressions).flatMap(wh -> wh.params(context)),
            Stream.ofNullable(elseExpression).flatMap(e -> e.params(context))
        );
    }

    @Override
    public Stream<Column> columnRefs() {
        return Stream.concat(
            streamSafely(whenThenExpressions).flatMap(SearchedWhenThen::columnRefs),
            Stream.ofNullable(elseExpression).flatMap(Sql::columnRefs)
        );
    }

    @Override
    public Stream<ColumnAlias> aliasRefs() {
        return Stream.concat(
            streamSafely(whenThenExpressions).flatMap(SearchedWhenThen::aliasRefs),
            Stream.ofNullable(elseExpression).flatMap(Sql::aliasRefs)
        );
    }

    // Projection

    @Override
    public Projection as(String alias) {
        requireNonBlank(alias, "No alias specified");
        return new SearchedCase(whenThenExpressions, elseExpression, alias);
    }

    @Override
    public Optional<ColumnAlias> alias() {
        return Optional.ofNullable(alias);
    }

    private ColumnAlias defaultAlias() {
        return ColumnAlias.generate("CASE_");
    }
}

1	/*
2	* Copyright (c) 2024-2025 Tore Eide Andersen
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package io.github.torand.fastersql.expression.cases;
17
18	import io.github.torand.fastersql.alias.ColumnAlias;
19	import io.github.torand.fastersql.expression.Expression;
20	import io.github.torand.fastersql.model.Column;
21	import io.github.torand.fastersql.projection.Projection;
22	import io.github.torand.fastersql.sql.Context;
23	import io.github.torand.fastersql.sql.Sql;
24
25	import java.util.List;
26	import java.util.Optional;
27	import java.util.stream.Stream;
28
29	import static io.github.torand.javacommons.contract.Requires.requireNonBlank;
30	import static io.github.torand.javacommons.contract.Requires.requireNonEmpty;
31	import static io.github.torand.javacommons.lang.StringHelper.nonBlank;
32	import static io.github.torand.javacommons.stream.StreamHelper.streamSafely;
33	import static java.util.Objects.nonNull;
34
35	/**
36	* Implements a searched CASE expression.
37	*/
38	public class SearchedCase implements Expression {
39	private final List<SearchedWhenThen> whenThenExpressions;
40	private final Expression elseExpression;
41	private final ColumnAlias alias;
42
43	SearchedCase(List<SearchedWhenThen> whenThenExpressions, Expression elseExpression, String alias) {	2✔
44	this.whenThenExpressions = requireNonEmpty(whenThenExpressions, "No when-then expressions specified");	8✔
45	this.elseExpression = elseExpression;	3✔
46	this.alias = nonBlank(alias) ? new ColumnAlias(alias) : defaultAlias();	12✔
47	}	1✔
48
49	// Sql
50
51	@Override
52	public String sql(Context context) {
53	StringBuilder sql = new StringBuilder();	4✔
54	sql.append("case ");	4✔
55	streamSafely(whenThenExpressions).forEach(wt -> sql.append(wt.sql(context)).append(" "));	16✔
56	if (nonNull(elseExpression)) {	4!
57	sql.append("else ").append(elseExpression.sql(context)).append(" ");	11✔
58	}
59	sql.append("end");	4✔
60	return sql.toString();	3✔
61	}
62
63	@Override
64	public Stream<Object> params(Context context) {
65	return Stream.concat(	4✔
66	streamSafely(whenThenExpressions).flatMap(wh -> wh.params(context)),	10✔
67	Stream.ofNullable(elseExpression).flatMap(e -> e.params(context))	8✔
68	);
69	}
70
71	@Override
72	public Stream<Column> columnRefs() {
73	return Stream.concat(	4✔
74	streamSafely(whenThenExpressions).flatMap(SearchedWhenThen::columnRefs),	5✔
75	Stream.ofNullable(elseExpression).flatMap(Sql::columnRefs)	3✔
76	);
77	}
78
79	@Override
80	public Stream<ColumnAlias> aliasRefs() {
81	return Stream.concat(	×
82	streamSafely(whenThenExpressions).flatMap(SearchedWhenThen::aliasRefs),	×
83	Stream.ofNullable(elseExpression).flatMap(Sql::aliasRefs)	×
84	);
85	}
86
87	// Projection
88
89	@Override
90	public Projection as(String alias) {
91	requireNonBlank(alias, "No alias specified");	6✔
92	return new SearchedCase(whenThenExpressions, elseExpression, alias);	9✔
93	}
94
95	@Override
96	public Optional<ColumnAlias> alias() {
97	return Optional.ofNullable(alias);	4✔
98	}
99
100	private ColumnAlias defaultAlias() {
101	return ColumnAlias.generate("CASE_");	3✔
102	}
103	}

torand / FasterSQL / 17073502945

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