Skip to content

Commit

Permalink
Format
Browse files Browse the repository at this point in the history
  • Loading branch information
@Mytherin
Mytherin committed Dec 31, 2019
1 parent caa3013 commit 6ddfdf7
Show file tree
Hide file tree
Showing 15 changed files with 96 additions and 64 deletions.
4 changes: 2 additions & 2 deletions benchmark/micro/in.cpp
View file
Expand Up @@ -10,7 +10,7 @@ using namespace std;
#define IN_LIST_ROW_COUNT 1000000
#define STRING_LENGTH 4

#define IN_QUERY_BODY(INCOUNT, NOT_IN) \
#define IN_QUERY_BODY(INCOUNT, NOT_IN) \
static constexpr const char *chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; \
string in_list; \
static string GenerateString(std::uniform_int_distribution<> &distribution, std::mt19937 &gen) { \
Expand Down Expand Up @@ -40,7 +40,7 @@ using namespace std;
} \
} \
virtual string GetQuery() { \
return "SELECT * FROM strings WHERE s " + (NOT_IN ? string("NOT ") : string("")) + "IN (" + in_list + ")"; \
return "SELECT * FROM strings WHERE s " + (NOT_IN ? string("NOT ") : string("")) + "IN (" + in_list + ")"; \
} \
virtual string VerifyResult(QueryResult *result) { \
if (!result->success) { \
Expand Down
3 changes: 1 addition & 2 deletions src/common/vector_operations/boolean_operators.cpp
View file
Expand Up @@ -59,8 +59,7 @@ void VectorOperations::Or(Vector &left, Vector &right, Vector &result) {
}

struct NotOperator {
template<class TA, class TR>
static inline TR Operation(TA left) {
template <class TA, class TR> static inline TR Operation(TA left) {
return !left;
}
};
Expand Down
5 changes: 2 additions & 3 deletions src/execution/expression_executor/execute_between.cpp
View file
Expand Up @@ -7,7 +7,6 @@
using namespace duckdb;
using namespace std;


struct BothInclusiveBetweenOperator {
template <class T> static inline bool Operation(T input, T lower, T upper) {
return GreaterThanEquals::Operation<T>(input, lower) && LessThanEquals::Operation<T>(input, upper);
Expand All @@ -32,9 +31,9 @@ struct ExclusiveBetweenOperator {
}
};

template<class OP>
template <class OP>
static index_t between_loop_type_switch(Vector &input, Vector &lower, Vector &upper, sel_t result[]) {
switch(input.type) {
switch (input.type) {
case TypeId::BOOLEAN:
case TypeId::TINYINT:
return templated_ternary_select<int8_t, int8_t, int8_t, OP>(input, lower, upper, result);
Expand Down
7 changes: 4 additions & 3 deletions src/execution/expression_executor/execute_conjunction.cpp
View file
Expand Up @@ -61,7 +61,7 @@ static void MergeSelectionVectorIntoResult(sel_t *result, index_t &result_count,
sel_t temp_result[STANDARD_VECTOR_SIZE];
index_t res_idx = 0, sel_idx = 0;
index_t temp_count = 0;
while(true) {
while (true) {
// the two sets should be disjunct
assert(result[res_idx] != sel[sel_idx]);
if (result[res_idx] < sel[sel_idx]) {
Expand Down Expand Up @@ -135,7 +135,8 @@ index_t ExpressionExecutor::Select(BoundConjunctionExpression &expr, ExpressionS
sel_t *result_vector = initial_sel == result ? intermediate_result : result;
for (index_t expr_idx = 0; expr_idx < expr.children.size(); expr_idx++) {
// first resolve the current expression
index_t new_count = Select(*expr.children[expr_idx], state->child_states[expr_idx].get(), expression_result);
index_t new_count =
Select(*expr.children[expr_idx], state->child_states[expr_idx].get(), expression_result);
if (new_count == 0) {
// no new qualifying entries: continue
continue;
Expand All @@ -161,7 +162,7 @@ index_t ExpressionExecutor::Select(BoundConjunctionExpression &expr, ExpressionS
// we figure this out by performing a merge of the remaining tuples and the resulting selection vector
index_t new_idx = 0;
remaining_count = 0;
for(index_t i = 0; i < current_count; i++) {
for (index_t i = 0; i < current_count; i++) {
auto entry = current_sel ? current_sel[i] : i;
if (new_idx >= new_count || expression_result[new_idx] != entry) {
remaining[remaining_count++] = entry;
Expand Down
4 changes: 2 additions & 2 deletions src/execution/operator/aggregate/physical_window.cpp
View file
Expand Up @@ -253,8 +253,8 @@ static void UpdateWindowBoundaries(BoundWindowExpression *wexpr, ChunkCollection
case WindowBoundary::EXPR_FOLLOWING:
assert(boundary_end_collection.column_count() > 0);
bounds.window_end =
row_idx + boundary_end_collection.GetValue(0, wexpr->end_expr->IsScalar() ? 0 : row_idx).GetValue<int64_t>() +
1;
row_idx +
boundary_end_collection.GetValue(0, wexpr->end_expr->IsScalar() ? 0 : row_idx).GetValue<int64_t>() + 1;

break;
default:
Expand Down
11 changes: 6 additions & 5 deletions src/include/duckdb/common/vector_operations/binary_loops.hpp
View file
Expand Up @@ -68,7 +68,7 @@ void templated_binary_loop(Vector &left, Vector &right, Vector &result) {
}
result.nullmask = right.nullmask;
binary_function_loop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP, IGNORE_NULL, true, false>(
ldata, rdata, result_data, result.count, result.sel_vector, result.nullmask);
ldata, rdata, result_data, result.count, result.sel_vector, result.nullmask);
} else if (right.IsConstant()) {
// right side is constant
result.sel_vector = left.sel_vector;
Expand All @@ -79,7 +79,7 @@ void templated_binary_loop(Vector &left, Vector &right, Vector &result) {
}
result.nullmask = left.nullmask;
binary_function_loop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, true>(
ldata, rdata, result_data, result.count, result.sel_vector, result.nullmask);
ldata, rdata, result_data, result.count, result.sel_vector, result.nullmask);
} else {
// neither side is a constant: loop over everything
assert(left.count == right.count);
Expand All @@ -88,8 +88,8 @@ void templated_binary_loop(Vector &left, Vector &right, Vector &result) {
result.sel_vector = left.sel_vector;
result.count = left.count;
result.nullmask = left.nullmask | right.nullmask;
binary_function_loop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, false>(ldata, rdata, result_data, result.count,
result.sel_vector, result.nullmask);
binary_function_loop<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, false>(
ldata, rdata, result_data, result.count, result.sel_vector, result.nullmask);
}
}

Expand Down Expand Up @@ -131,7 +131,8 @@ template <class T, class OP> void templated_divmod_loop(Vector &left, Vector &ri
// right side is normal constant, use left nullmask and do
// computation
result.nullmask = left.nullmask;
binary_function_loop<T, T, T, OP, false, false, true>(ldata, rdata, result_data, result.count, result.sel_vector, result.nullmask);
binary_function_loop<T, T, T, OP, false, false, true>(ldata, rdata, result_data, result.count,
result.sel_vector, result.nullmask);
} else {
assert(left.count == right.count);
// OR nullmasks together
Expand Down
8 changes: 4 additions & 4 deletions src/include/duckdb/common/vector_operations/binary_select_loops.hpp
View file
Expand Up @@ -58,15 +58,15 @@ index_t templated_binary_select(Vector &left, Vector &right, sel_t result[]) {
}
// left side is normal constant, use right nullmask and do
// computation
return binary_select_loop<LEFT_TYPE, RIGHT_TYPE, OP, true, false>(
ldata, rdata, result, right.count, right.sel_vector, right.nullmask);
return binary_select_loop<LEFT_TYPE, RIGHT_TYPE, OP, true, false>(ldata, rdata, result, right.count,
right.sel_vector, right.nullmask);
} else if (right.IsConstant()) {
if (right.nullmask[0]) {
// right side is constant NULL, no results
return 0;
}
return binary_select_loop<LEFT_TYPE, RIGHT_TYPE, OP, false, true>(
ldata, rdata, result, left.count, left.sel_vector, left.nullmask);
return binary_select_loop<LEFT_TYPE, RIGHT_TYPE, OP, false, true>(ldata, rdata, result, left.count,
left.sel_vector, left.nullmask);
} else {
assert(left.count == right.count);
assert(left.sel_vector == right.sel_vector);
Expand Down
34 changes: 22 additions & 12 deletions src/include/duckdb/common/vector_operations/ternary_loops.hpp
View file
Expand Up @@ -14,10 +14,11 @@

namespace duckdb {

template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE, class OP, bool IGNORE_NULL, bool A_CONSTANT, bool B_CONSTANT, bool C_CONSTANT>
template <class A_TYPE, class B_TYPE, class C_TYPE, class RESULT_TYPE, class OP, bool IGNORE_NULL, bool A_CONSTANT,
bool B_CONSTANT, bool C_CONSTANT>
static inline void ternary_function_loop(A_TYPE *__restrict adata, B_TYPE *__restrict bdata, C_TYPE *__restrict cdata,
RESULT_TYPE *__restrict result_data, index_t count,
sel_t *__restrict sel_vector, nullmask_t &nullmask) {
RESULT_TYPE *__restrict result_data, index_t count,
sel_t *__restrict sel_vector, nullmask_t &nullmask) {
if (!A_CONSTANT) {
ASSERT_RESTRICT(adata, adata + count, result_data, result_data + count);
}
Expand All @@ -30,12 +31,14 @@ static inline void ternary_function_loop(A_TYPE *__restrict adata, B_TYPE *__res
if (IGNORE_NULL && nullmask.any()) {
VectorOperations::Exec(sel_vector, count, [&](index_t i, index_t k) {
if (!nullmask[i]) {
result_data[i] = OP::Operation(adata[A_CONSTANT ? 0 : i], bdata[B_CONSTANT ? 0 : i], cdata[C_CONSTANT ? 0 : i]);
result_data[i] =
OP::Operation(adata[A_CONSTANT ? 0 : i], bdata[B_CONSTANT ? 0 : i], cdata[C_CONSTANT ? 0 : i]);
}
});
} else {
VectorOperations::Exec(sel_vector, count, [&](index_t i, index_t k) {
result_data[i] = OP::Operation(adata[A_CONSTANT ? 0 : i], bdata[B_CONSTANT ? 0 : i], cdata[C_CONSTANT ? 0 : i]);
result_data[i] =
OP::Operation(adata[A_CONSTANT ? 0 : i], bdata[B_CONSTANT ? 0 : i], cdata[C_CONSTANT ? 0 : i]);
});
}
}
Expand All @@ -57,7 +60,8 @@ void templated_ternary_loop(Vector &a, Vector &b, Vector &c, Vector &result) {
return;
}
result.nullmask = c.nullmask;
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, true, true, false>(adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, true, true, false>(
adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
} else if (c.IsConstant()) {
// AC constant
result.sel_vector = b.sel_vector;
Expand All @@ -67,13 +71,15 @@ void templated_ternary_loop(Vector &a, Vector &b, Vector &c, Vector &result) {
return;
}
result.nullmask = b.nullmask;
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, true, false, true>(adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, true, false, true>(
adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
} else {
// A constant
result.sel_vector = b.sel_vector;
result.count = b.count;
result.nullmask = a.nullmask | c.nullmask;
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, true, false, false>(adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, true, false, false>(
adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
}
} else if (b.IsConstant()) {
result.sel_vector = a.sel_vector;
Expand All @@ -89,11 +95,13 @@ void templated_ternary_loop(Vector &a, Vector &b, Vector &c, Vector &result) {
return;
}
result.nullmask = a.nullmask;
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, true, true>(adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, true, true>(
adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
} else {
// B constant
result.nullmask = a.nullmask | c.nullmask;
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, true, false>(adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, true, false>(
adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
}
} else if (c.IsConstant()) {
// C constant
Expand All @@ -105,13 +113,15 @@ void templated_ternary_loop(Vector &a, Vector &b, Vector &c, Vector &result) {
}
// OR the nullmask of A and B
result.nullmask = a.nullmask | b.nullmask;
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, false, true>(adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, false, true>(
adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
} else {
// no constants
result.sel_vector = a.sel_vector;
result.count = a.count;
result.nullmask = a.nullmask | b.nullmask | c.nullmask;
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, false, false>(adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
ternary_function_loop<A_TYPE, B_TYPE, C_TYPE, RESULT_TYPE, OP, IGNORE_NULL, false, false, false>(
adata, bdata, cdata, result_data, result.count, result.sel_vector, result.nullmask);
}
}

Expand Down
28 changes: 18 additions & 10 deletions src/include/duckdb/common/vector_operations/ternary_select_loops.hpp
View file
Expand Up @@ -16,12 +16,13 @@ namespace duckdb {

template <class A_TYPE, class B_TYPE, class C_TYPE, class OP, bool A_CONSTANT, bool B_CONSTANT, bool C_CONSTANT>
static inline index_t ternary_select_loop(A_TYPE *__restrict adata, B_TYPE *__restrict bdata, C_TYPE *__restrict cdata,
sel_t *__restrict result, index_t count, sel_t *__restrict sel_vector,
nullmask_t &nullmask) {
sel_t *__restrict result, index_t count, sel_t *__restrict sel_vector,
nullmask_t &nullmask) {
index_t result_count = 0;
if (nullmask.any()) {
VectorOperations::Exec(sel_vector, count, [&](index_t i, index_t k) {
if (!nullmask[i] && OP::Operation(adata[A_CONSTANT ? 0 : i], bdata[B_CONSTANT ? 0 : i], cdata[C_CONSTANT ? 0 : i])) {
if (!nullmask[i] &&
OP::Operation(adata[A_CONSTANT ? 0 : i], bdata[B_CONSTANT ? 0 : i], cdata[C_CONSTANT ? 0 : i])) {
result[result_count++] = i;
}
});
Expand Down Expand Up @@ -60,17 +61,20 @@ index_t templated_ternary_select(Vector &a, Vector &b, Vector &c, sel_t result[]
}
}
// AB constant
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, true, true, false>(adata, bdata, cdata, result, c.count, c.sel_vector, c.nullmask);
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, true, true, false>(
adata, bdata, cdata, result, c.count, c.sel_vector, c.nullmask);
} else if (c.IsConstant()) {
if (c.nullmask[0]) {
return 0;
}
// AC constant
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, true, false, true>(adata, bdata, cdata, result, b.count, b.sel_vector, b.nullmask);
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, true, false, true>(
adata, bdata, cdata, result, b.count, b.sel_vector, b.nullmask);
} else {
// A constant
auto nullmask = b.nullmask | c.nullmask;
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, true, false, false>(adata, bdata, cdata, result, b.count, b.sel_vector, nullmask);
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, true, false, false>(adata, bdata, cdata, result,
b.count, b.sel_vector, nullmask);
}
} else if (b.IsConstant()) {
if (b.nullmask[0]) {
Expand All @@ -81,23 +85,27 @@ index_t templated_ternary_select(Vector &a, Vector &b, Vector &c, sel_t result[]
return 0;
}
// BC constant
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, false, true, true>(adata, bdata, cdata, result, a.count, a.sel_vector, a.nullmask);
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, false, true, true>(
adata, bdata, cdata, result, a.count, a.sel_vector, a.nullmask);
} else {
// B constant
auto nullmask = a.nullmask | c.nullmask;
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, false, true, false>(adata, bdata, cdata, result, a.count, a.sel_vector, nullmask);
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, false, true, false>(adata, bdata, cdata, result,
a.count, a.sel_vector, nullmask);
}
} else if (c.IsConstant()) {
if (c.nullmask[0]) {
return 0;
}
// C constant
auto nullmask = a.nullmask | b.nullmask;
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, false, false, true>(adata, bdata, cdata, result, a.count, a.sel_vector, nullmask);
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, false, false, true>(adata, bdata, cdata, result, a.count,
a.sel_vector, nullmask);
} else {
// no constants
auto nullmask = a.nullmask | b.nullmask | c.nullmask;
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, false, false, false>(adata, bdata, cdata, result, a.count, a.sel_vector, nullmask);
return ternary_select_loop<A_TYPE, B_TYPE, C_TYPE, OP, false, false, false>(adata, bdata, cdata, result,
a.count, a.sel_vector, nullmask);
}
}

Expand Down
3 changes: 2 additions & 1 deletion src/include/duckdb/planner/expression/bound_between_expression.hpp
View file
Expand Up @@ -14,7 +14,8 @@ namespace duckdb {

class BoundBetweenExpression : public Expression {
public:
BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower, unique_ptr<Expression> upper, bool lower_inclusive, bool upper_inclusive);
BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower, unique_ptr<Expression> upper,
bool lower_inclusive, bool upper_inclusive);

unique_ptr<Expression> input;
unique_ptr<Expression> lower;
Expand Down

0 comments on commit 6ddfdf7

Please sign in to comment.