diff options
77 files changed, 9385 insertions, 108 deletions
diff --git a/src/mongo/db/exec/sbe/SConscript b/src/mongo/db/exec/sbe/SConscript index bf2d6170cf1..9be25c996cd 100644 --- a/src/mongo/db/exec/sbe/SConscript +++ b/src/mongo/db/exec/sbe/SConscript @@ -169,13 +169,16 @@ env.CppUnitTest( 'expressions/sbe_bson_size_test.cpp', 'expressions/sbe_coerce_to_string_test.cpp', 'expressions/sbe_concat_test.cpp', + 'expressions/sbe_constant_test.cpp', 'expressions/sbe_date_add_test.cpp', 'expressions/sbe_date_diff_test.cpp', 'expressions/sbe_date_to_parts_test.cpp', 'expressions/sbe_date_trunc_test.cpp', 'expressions/sbe_day_of_expressions_test.cpp', 'expressions/sbe_extract_sub_array_builtin_test.cpp', + 'expressions/sbe_fail_test.cpp', 'expressions/sbe_get_element_builtin_test.cpp', + 'expressions/sbe_if_test.cpp', 'expressions/sbe_index_of_test.cpp', 'expressions/sbe_is_array_empty_builtin_test.cpp', 'expressions/sbe_is_member_builtin_test.cpp', @@ -186,6 +189,7 @@ env.CppUnitTest( 'expressions/sbe_mod_expression_test.cpp', 'expressions/sbe_new_array_from_range_builtin_test.cpp', 'expressions/sbe_prim_binary_test.cpp', + 'expressions/sbe_prim_unary_test.cpp', 'expressions/sbe_regex_test.cpp', 'expressions/sbe_replace_one_expression_test.cpp', 'expressions/sbe_reverse_array_builtin_test.cpp', @@ -196,6 +200,7 @@ env.CppUnitTest( 'expressions/sbe_trigonometric_expressions_test.cpp', 'expressions/sbe_trunc_builtin_test.cpp', 'expressions/sbe_ts_second_ts_increment_test.cpp', + 'expressions/sbe_variable_test.cpp', 'sbe_column_scan_test.cpp', 'sbe_filter_test.cpp', 'sbe_hash_agg_test.cpp', diff --git a/src/mongo/db/exec/sbe/expression_test_base.h b/src/mongo/db/exec/sbe/expression_test_base.h index e3565016243..59c64a8d67f 100644 --- a/src/mongo/db/exec/sbe/expression_test_base.h +++ b/src/mongo/db/exec/sbe/expression_test_base.h @@ -34,6 +34,8 @@ #include "mongo/db/exec/sbe/sbe_unittest.h" #include "mongo/db/exec/sbe/stages/co_scan.h" #include "mongo/db/exec/sbe/values/slot.h" +#include "mongo/db/exec/sbe/values/value.h" +#include "mongo/db/exec/sbe/values/value_printer.h" #include "mongo/db/exec/sbe/vm/vm.h" #include "mongo/db/exec/sbe/vm/vm_printer.h" #include "mongo/unittest/golden_test.h" @@ -125,6 +127,8 @@ protected: } void executeAndPrintVariation(std::ostream& os, const vm::CodeFragment& code) { + auto valuePrinter = makeValuePrinter(os); + os << "-- EXECUTE VARIATION:" << std::endl; if (!boundAccessors.empty()) { bool first = true; @@ -135,14 +139,24 @@ protected: } else { first = false; } - os << p.first << ": " << p.second->getViewOfValue(); + os << p.first << ": "; + + auto [tag, val] = p.second->getViewOfValue(); + valuePrinter.writeValueToStream(tag, val); } os << "]" << std::endl; + } + try { auto [owned, tag, val] = _vm.run(&code); value::ValueGuard guard(owned, tag, val); - os << "RESULT: " << std::make_pair(tag, val) << std::endl << std::endl; + os << "RESULT: "; + valuePrinter.writeValueToStream(tag, val); + os << std::endl; + } catch (const DBException& e) { + os << "EXCEPTION: " << e.toString() << std::endl; } + os << std::endl; } void runAndAssertNothing(const vm::CodeFragment* compiledExpression) { @@ -156,6 +170,12 @@ protected: value::bitcastFrom<const char*>(ba.objdata())); } + + static std::pair<value::TypeTags, value::Value> makeBsonObject(const BSONObj& bo) { + return value::copyValue(value::TypeTags::bsonObject, + value::bitcastFrom<const char*>(bo.objdata())); + } + static std::pair<value::TypeTags, value::Value> makeArraySet(const BSONArray& arr) { auto [tmpTag, tmpVal] = makeBsonArray(arr); value::ValueGuard tmpGuard{tmpTag, tmpVal}; @@ -202,10 +222,36 @@ protected: return {arrTag, arrVal}; } + static std::pair<value::TypeTags, value::Value> makeObject(const BSONObj& obj) { + auto [tmpTag, tmpVal] = makeBsonObject(obj); + value::ValueGuard tmpGuard{tmpTag, tmpVal}; + + value::ObjectEnumerator enumerator{tmpTag, tmpVal}; + + auto [objTag, objVal] = value::makeNewObject(); + value::ValueGuard guard{objTag, objVal}; + + auto objView = value::getObjectView(objVal); + + while (!enumerator.atEnd()) { + auto [tag, val] = enumerator.getViewOfValue(); + auto [copyTag, copyVal] = value::copyValue(tag, val); + objView->push_back(enumerator.getFieldName(), copyTag, copyVal); + enumerator.advance(); + } + guard.reset(); + + return {objTag, objVal}; + } + static std::pair<value::TypeTags, value::Value> makeNothing() { return {value::TypeTags::Nothing, value::bitcastFrom<int64_t>(0)}; } + static std::pair<value::TypeTags, value::Value> makeNull() { + return {value::TypeTags::Null, value::bitcastFrom<int64_t>(0)}; + } + static std::pair<value::TypeTags, value::Value> makeInt32(int32_t value) { return {value::TypeTags::NumberInt32, value::bitcastFrom<int32_t>(value)}; } @@ -234,6 +280,12 @@ protected: return makeC(p.first, p.second); } + template <typename Stream> + value::ValuePrinter<Stream> makeValuePrinter(Stream& stream) { + return value::ValuePrinters::make( + stream, PrintOptions().useTagForAmbiguousValues(true).normalizeOutput(true)); + } + private: value::SlotIdGenerator _slotIdGenerator; CoScanStage _emptyStage{kEmptyPlanNodeId}; @@ -242,4 +294,38 @@ private: std::vector<std::pair<value::SlotId, value::SlotAccessor*>> boundAccessors; }; + +class GoldenEExpressionTestFixture : public EExpressionTestFixture { +public: + GoldenEExpressionTestFixture() {} + + void run() { + GoldenTestContext ctx(&goldenTestConfigSbe); + auto guard = ScopeGuard([&] { gctx = nullptr; }); + gctx = &ctx; + gctx->printTestHeader(GoldenTestContext::HeaderFormat::Text); + Test::run(); + } + +protected: + GoldenTestContext* gctx; +}; + +class ValueVectorGuard { + ValueVectorGuard() = delete; + ValueVectorGuard& operator=(const ValueVectorGuard&) = delete; + +public: + ValueVectorGuard(std::vector<TypedValue>& values) : _values(values) {} + + ~ValueVectorGuard() { + for (auto p : _values) { + value::releaseValue(p.first, p.second); + } + } + +private: + std::vector<TypedValue>& _values; +}; + } // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/expressions/expression.cpp b/src/mongo/db/exec/sbe/expressions/expression.cpp index 071f74f33a8..0ddf262dd76 100644 --- a/src/mongo/db/exec/sbe/expressions/expression.cpp +++ b/src/mongo/db/exec/sbe/expressions/expression.cpp @@ -40,6 +40,7 @@ #include "mongo/db/exec/sbe/stages/spool.h" #include "mongo/db/exec/sbe/stages/stages.h" #include "mongo/db/exec/sbe/values/arith_common.h" +#include "mongo/db/exec/sbe/values/value_printer.h" #include "mongo/db/exec/sbe/vm/datetime.h" #include "mongo/util/str.h" @@ -120,7 +121,9 @@ vm::CodeFragment EConstant::compileDirect(CompileCtx& ctx) const { std::vector<DebugPrinter::Block> EConstant::debugPrint() const { std::vector<DebugPrinter::Block> ret; std::stringstream ss; - ss << std::make_pair(_tag, _val); + value::ValuePrinters::make(ss, + PrintOptions().useTagForAmbiguousValues(true).normalizeOutput(true)) + .writeValueToStream(_tag, _val); ret.emplace_back(ss.str()); diff --git a/src/mongo/db/exec/sbe/expressions/sbe_constant_test.cpp b/src/mongo/db/exec/sbe/expressions/sbe_constant_test.cpp new file mode 100644 index 00000000000..cf4059456b5 --- /dev/null +++ b/src/mongo/db/exec/sbe/expressions/sbe_constant_test.cpp @@ -0,0 +1,81 @@ +/** + * Copyright (C) 2022-present MongoDB, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the Server Side Public License, version 1, + * as published by MongoDB, Inc. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * Server Side Public License for more details. + * + * You should have received a copy of the Server Side Public License + * along with this program. If not, see + * <http://www.mongodb.com/licensing/server-side-public-license>. + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the Server Side Public License in all respects for + * all of the code used other than as permitted herein. If you modify file(s) + * with this exception, you may extend this exception to your version of the + * file(s), but you are not obligated to do so. If you do not wish to do so, + * delete this exception statement from your version. If you delete this + * exception statement from all source files in the program, then also delete + * it in the license file. + */ + +#include "mongo/db/exec/sbe/expression_test_base.h" +#include "mongo/db/exec/sbe/values/bson.h" + +namespace mongo::sbe { + +class SBEConstantTest : public GoldenEExpressionTestFixture { +public: + // Takes ownership of the value. + void verifyConstantExpression(std::ostream& os, std::pair<value::TypeTags, value::Value> p) { + verifyConstantExpression(os, p.first, p.second); + } + + // Takes ownership of the value. + void verifyConstantExpression(std::ostream& os, value::TypeTags tag, value::Value val) { + auto expr = sbe::makeE<EConstant>(tag, val); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + auto [tagActual, valActual] = runCompiledExpression(compiledExpr.get()); + value::ValueGuard guard(tagActual, valActual); + + ASSERT_THAT(std::make_pair(tagActual, valActual), ValueEq(std::make_pair(tag, val))); + } +}; + +TEST_F(SBEConstantTest, SbeConstants) { + auto& os = gctx->outStream(); + + verifyConstantExpression(os, value::TypeTags::Nothing, 0); + verifyConstantExpression(os, value::TypeTags::Null, 0); + verifyConstantExpression(os, value::TypeTags::Boolean, value::bitcastFrom<bool>(true)); + verifyConstantExpression(os, value::TypeTags::NumberInt32, value::bitcastFrom<int32_t>(123)); + verifyConstantExpression(os, value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(123)); + verifyConstantExpression(os, value::TypeTags::NumberDouble, value::bitcastFrom<double>(123.0)); + verifyConstantExpression(os, value::TypeTags::MinKey, 0); + verifyConstantExpression(os, value::TypeTags::MaxKey, 0); + + verifyConstantExpression(os, value::makeCopyDecimal(Decimal128(123.0))); + verifyConstantExpression(os, value::makeSmallString("abc"_sd)); + verifyConstantExpression(os, value::makeBigString("abcdefghijklmnop"_sd)); + verifyConstantExpression(os, value::makeNewRecordId(123)); + verifyConstantExpression( + os, value::makeCopyObjectId(std::array<uint8_t, 12>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11})); + + verifyConstantExpression(os, makeArray(BSON_ARRAY(1 << 2 << 3))); + verifyConstantExpression(os, makeArraySet(BSON_ARRAY(2 << 1 << 3))); + verifyConstantExpression(os, makeObject(BSON("a"_sd << 1 << "b"_sd << 2))); +} + +} // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/expressions/sbe_fail_test.cpp b/src/mongo/db/exec/sbe/expressions/sbe_fail_test.cpp new file mode 100644 index 00000000000..095db37f72d --- /dev/null +++ b/src/mongo/db/exec/sbe/expressions/sbe_fail_test.cpp @@ -0,0 +1,81 @@ +/** + * Copyright (C) 2022-present MongoDB, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the Server Side Public License, version 1, + * as published by MongoDB, Inc. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * Server Side Public License for more details. + * + * You should have received a copy of the Server Side Public License + * along with this program. If not, see + * <http://www.mongodb.com/licensing/server-side-public-license>. + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the Server Side Public License in all respects for + * all of the code used other than as permitted herein. If you modify file(s) + * with this exception, you may extend this exception to your version of the + * file(s), but you are not obligated to do so. If you do not wish to do so, + * delete this exception statement from your version. If you delete this + * exception statement from all source files in the program, then also delete + * it in the license file. + */ + +#include "mongo/db/exec/sbe/expression_test_base.h" + +namespace mongo::sbe { + +using SBEFailTest = GoldenEExpressionTestFixture; + +TEST_F(SBEFailTest, SimpleFail) { + auto& os = gctx->outStream(); + + auto expr = sbe::makeE<EFail>(ErrorCodes::Error::BadValue, "test"_sd); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + executeAndPrintVariation(os, *compiledExpr); +} + +TEST_F(SBEFailTest, FailWithAddDecimal) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor condAccessor; + + auto expr = sbe::makeE<EPrimBinary>(EPrimBinary::Op::add, + makeC(value::makeCopyDecimal(Decimal128(123))), + sbe::makeE<EFail>(ErrorCodes::Error::BadValue, "test"_sd)); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + executeAndPrintVariation(os, *compiledExpr); +} + +TEST_F(SBEFailTest, FailWithLocalBind) { + auto& os = gctx->outStream(); + + FrameId frame = 10; + auto expr = sbe::makeE<ELocalBind>(frame, + makeEs(makeC(value::makeCopyDecimal(Decimal128(123)))), + sbe::makeE<EFail>(ErrorCodes::Error::BadValue, "test"_sd)); + + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + executeAndPrintVariation(os, *compiledExpr); +} + + +} // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/expressions/sbe_if_test.cpp b/src/mongo/db/exec/sbe/expressions/sbe_if_test.cpp new file mode 100644 index 00000000000..87f7476da2a --- /dev/null +++ b/src/mongo/db/exec/sbe/expressions/sbe_if_test.cpp @@ -0,0 +1,259 @@ +/** + * Copyright (C) 2022-present MongoDB, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the Server Side Public License, version 1, + * as published by MongoDB, Inc. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * Server Side Public License for more details. + * + * You should have received a copy of the Server Side Public License + * along with this program. If not, see + * <http://www.mongodb.com/licensing/server-side-public-license>. + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the Server Side Public License in all respects for + * all of the code used other than as permitted herein. If you modify file(s) + * with this exception, you may extend this exception to your version of the + * file(s), but you are not obligated to do so. If you do not wish to do so, + * delete this exception statement from your version. If you delete this + * exception statement from all source files in the program, then also delete + * it in the license file. + */ + +#include "mongo/db/exec/sbe/expression_test_base.h" + +namespace mongo::sbe { + +class SBEIfTest : public GoldenEExpressionTestFixture { +protected: + std::vector<TypedValue> boolTestValues = {makeNothing(), makeBool(false), makeBool(true)}; + ValueVectorGuard boolTestValuesGuard{boolTestValues}; +}; + +TEST_F(SBEIfTest, SimpleIf) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor condAccessor; + + auto condSlot = bindAccessor(&condAccessor); + + auto expr = sbe::makeE<EIf>(makeE<EVariable>(condSlot), + makeC(value::makeNewString("then")), + makeC(value::makeNewString("else"))); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify input variations. + for (auto cond : boolTestValues) { + condAccessor.reset(cond.first, cond.second); + executeAndPrintVariation(os, *compiledExpr); + } +} + +TEST_F(SBEIfTest, NestedIfCond) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor condAccessor; + + auto condSlot = bindAccessor(&condAccessor); + + + auto ifExpr = + sbe::makeE<EIf>(makeE<EVariable>(condSlot), makeC(makeBool(false)), makeC(makeBool(true))); + + auto expr = sbe::makeE<EIf>(std::move(ifExpr), + makeC(value::makeNewString("then")), + makeC(value::makeNewString("else"))); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify input variations. + for (auto cond : boolTestValues) { + condAccessor.reset(cond.first, cond.second); + executeAndPrintVariation(os, *compiledExpr); + } +} + +TEST_F(SBEIfTest, NestedIfThen) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor condAccessor; + value::ViewOfValueAccessor cond2Accessor; + + auto condSlot = bindAccessor(&condAccessor); + auto cond2Slot = bindAccessor(&cond2Accessor); + + + auto ifExpr = sbe::makeE<EIf>(makeE<EVariable>(condSlot), + makeC(value::makeNewString("then")), + makeC(value::makeNewString("else"))); + + auto expr = sbe::makeE<EIf>( + makeE<EVariable>(cond2Slot), std::move(ifExpr), makeC(value::makeNewString("else2"))); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify input variations. + for (auto cond : boolTestValues) + for (auto cond2 : boolTestValues) { + condAccessor.reset(cond.first, cond.second); + cond2Accessor.reset(cond2.first, cond2.second); + executeAndPrintVariation(os, *compiledExpr); + } +} + + +TEST_F(SBEIfTest, NestedIfElse) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor condAccessor; + value::ViewOfValueAccessor cond2Accessor; + + auto condSlot = bindAccessor(&condAccessor); + auto cond2Slot = bindAccessor(&cond2Accessor); + + auto ifExpr = sbe::makeE<EIf>(makeE<EVariable>(condSlot), + makeC(value::makeNewString("then")), + makeC(value::makeNewString("else"))); + + auto expr = sbe::makeE<EIf>( + makeE<EVariable>(cond2Slot), makeC(value::makeNewString("then2")), std::move(ifExpr)); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify input variations. + for (auto cond : boolTestValues) + for (auto cond2 : boolTestValues) { + condAccessor.reset(cond.first, cond.second); + cond2Accessor.reset(cond2.first, cond2.second); + executeAndPrintVariation(os, *compiledExpr); + } +} + + +TEST_F(SBEIfTest, IfWithLogicAnd) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor condAccessor; + value::ViewOfValueAccessor cond2Accessor; + + auto condSlot = bindAccessor(&condAccessor); + auto cond2Slot = bindAccessor(&cond2Accessor); + + + auto expr = sbe::makeE<EIf>(makeE<EPrimBinary>(EPrimBinary::Op::logicAnd, + makeE<EVariable>(condSlot), + makeE<EVariable>(cond2Slot)), + makeC(value::makeNewString("then")), + makeC(value::makeNewString("else"))); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify input variations. + for (auto cond : boolTestValues) + for (auto cond2 : boolTestValues) { + condAccessor.reset(cond.first, cond.second); + cond2Accessor.reset(cond2.first, cond2.second); + executeAndPrintVariation(os, *compiledExpr); + } +} + +TEST_F(SBEIfTest, IfWithLogicOr) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor condAccessor; + value::ViewOfValueAccessor cond2Accessor; + + auto condSlot = bindAccessor(&condAccessor); + auto cond2Slot = bindAccessor(&cond2Accessor); + + + auto expr = sbe::makeE<EIf>(makeE<EPrimBinary>(EPrimBinary::Op::logicOr, + makeE<EVariable>(condSlot), + makeE<EVariable>(cond2Slot)), + makeC(value::makeNewString("then")), + makeC(value::makeNewString("else"))); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify input variations. + for (auto cond : boolTestValues) + for (auto cond2 : boolTestValues) { + condAccessor.reset(cond.first, cond.second); + cond2Accessor.reset(cond2.first, cond2.second); + executeAndPrintVariation(os, *compiledExpr); + } +} + +TEST_F(SBEIfTest, IfWithLogicNot) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor condAccessor; + + auto condSlot = bindAccessor(&condAccessor); + + auto expr = + sbe::makeE<EIf>(makeE<EPrimUnary>(EPrimUnary::Op::logicNot, makeE<EVariable>(condSlot)), + makeC(value::makeNewString("then")), + makeC(value::makeNewString("else"))); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify input variations. + for (auto cond : boolTestValues) { + condAccessor.reset(cond.first, cond.second); + executeAndPrintVariation(os, *compiledExpr); + } +} + + +TEST_F(SBEIfTest, IfWithFillEmpty) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor condAccessor; + value::ViewOfValueAccessor cond2Accessor; + + auto condSlot = bindAccessor(&condAccessor); + auto cond2Slot = bindAccessor(&cond2Accessor); + + auto expr = sbe::makeE<EIf>(makeE<EPrimBinary>(EPrimBinary::Op::fillEmpty, + makeE<EVariable>(condSlot), + makeE<EVariable>(cond2Slot)), + makeC(value::makeNewString("then")), + makeC(value::makeNewString("else"))); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify input variations. + for (auto cond : boolTestValues) + for (auto cond2 : boolTestValues) { + condAccessor.reset(cond.first, cond.second); + cond2Accessor.reset(cond2.first, cond2.second); + executeAndPrintVariation(os, *compiledExpr); + } +} + +} // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/expressions/sbe_lambda_test.cpp b/src/mongo/db/exec/sbe/expressions/sbe_lambda_test.cpp index df8a2835244..a355b12873b 100644 --- a/src/mongo/db/exec/sbe/expressions/sbe_lambda_test.cpp +++ b/src/mongo/db/exec/sbe/expressions/sbe_lambda_test.cpp @@ -30,9 +30,11 @@ #include "mongo/db/exec/sbe/expression_test_base.h" namespace mongo::sbe { -using SBELambdaTest = EExpressionTestFixture; +using SBELambdaTest = GoldenEExpressionTestFixture; TEST_F(SBELambdaTest, TraverseP_AddOneToArray) { + auto& os = gctx->outStream(); + value::ViewOfValueAccessor slotAccessor; auto argSlot = bindAccessor(&slotAccessor); FrameId frame = 10; @@ -44,22 +46,21 @@ TEST_F(SBELambdaTest, TraverseP_AddOneToArray) { makeE<EVariable>(frame, 0), makeC(makeInt32(1)))), makeC(makeNothing()))); + printInputExpression(os, *expr); + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); auto bsonArr = BSON_ARRAY(1 << 2 << 3); slotAccessor.reset(value::TypeTags::bsonArray, value::bitcastFrom<const char*>(bsonArr.objdata())); - auto [tag, val] = runCompiledExpression(compiledExpr.get()); - value::ValueGuard guard(tag, val); - - auto [tagExpected, valExpected] = makeArray(BSON_ARRAY(2 << 3 << 4)); - value::ValueGuard expectedGuard(tagExpected, valExpected); - - ASSERT_THAT(std::make_pair(tag, val), ValueEq(std::make_pair(tagExpected, valExpected))); + executeAndPrintVariation(os, *compiledExpr); } TEST_F(SBELambdaTest, TraverseF_OpEq) { + auto& os = gctx->outStream(); + value::ViewOfValueAccessor slotAccessor; auto argSlot = bindAccessor(&slotAccessor); FrameId frame = 10; @@ -71,19 +72,22 @@ TEST_F(SBELambdaTest, TraverseF_OpEq) { makeE<EVariable>(frame, 0), makeC(makeInt32(3)))), makeC(makeNothing()))); + printInputExpression(os, *expr); + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + auto bsonArr = BSON_ARRAY(1 << 2 << 3 << 4); slotAccessor.reset(value::TypeTags::bsonArray, value::bitcastFrom<const char*>(bsonArr.objdata())); - auto [tag, val] = runCompiledExpression(compiledExpr.get()); - - value::ValueGuard guard(tag, val); - ASSERT_THAT(std::make_pair(tag, val), ValueEq(makeBool(true))); + executeAndPrintVariation(os, *compiledExpr); } TEST_F(SBELambdaTest, TraverseF_WithLocalBind) { + auto& os = gctx->outStream(); + value::ViewOfValueAccessor slotAccessor; auto argSlot = bindAccessor(&slotAccessor); FrameId frame1 = 10; @@ -101,22 +105,20 @@ TEST_F(SBELambdaTest, TraverseF_WithLocalBind) { sbe::makeE<EVariable>(frame2, 1), sbe::makeE<EVariable>(frame2, 2)); - auto expr = sbe::makeE<ELocalBind>( frame2, makeEs(makeE<EVariable>(argSlot), makeC(makeInt32(10)), makeC(makeInt32(20))), std::move(ifExpr)); + printInputExpression(os, *expr); auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); auto bsonArr = BSON_ARRAY(1 << 2 << 3 << 4); slotAccessor.reset(value::TypeTags::bsonArray, value::bitcastFrom<const char*>(bsonArr.objdata())); - auto [tag, val] = runCompiledExpression(compiledExpr.get()); - - value::ValueGuard guard(tag, val); - ASSERT_THAT(std::make_pair(tag, val), ValueEq(makeInt32(10))); + executeAndPrintVariation(os, *compiledExpr); } } // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/expressions/sbe_local_bind_test.cpp b/src/mongo/db/exec/sbe/expressions/sbe_local_bind_test.cpp index da7f4d91907..a21f8e677c3 100644 --- a/src/mongo/db/exec/sbe/expressions/sbe_local_bind_test.cpp +++ b/src/mongo/db/exec/sbe/expressions/sbe_local_bind_test.cpp @@ -30,9 +30,11 @@ #include "mongo/db/exec/sbe/expression_test_base.h" namespace mongo::sbe { -using SBELocalBindTest = EExpressionTestFixture; +using SBELocalBindTest = GoldenEExpressionTestFixture; TEST_F(SBELocalBindTest, OneVariable) { + auto& os = gctx->outStream(); + value::ViewOfValueAccessor slotAccessor; FrameId frame = 10; auto expr = sbe::makeE<ELocalBind>(frame, @@ -40,14 +42,17 @@ TEST_F(SBELocalBindTest, OneVariable) { makeE<EPrimBinary>(EPrimBinary::Op::add, makeE<EVariable>(frame, 0), makeE<EVariable>(frame, 0))); + printInputExpression(os, *expr); + auto compiledExpr = compileExpression(*expr); - auto [tag, val] = runCompiledExpression(compiledExpr.get()); - value::ValueGuard guard(tag, val); + printCompiledExpression(os, *compiledExpr); - ASSERT_THAT(std::make_pair(tag, val), ValueEq(makeInt32(20))); + executeAndPrintVariation(os, *compiledExpr); } TEST_F(SBELocalBindTest, TwoVariables) { + auto& os = gctx->outStream(); + value::ViewOfValueAccessor slotAccessor; FrameId frame = 10; auto expr = sbe::makeE<ELocalBind>(frame, @@ -55,14 +60,17 @@ TEST_F(SBELocalBindTest, TwoVariables) { makeE<EPrimBinary>(EPrimBinary::Op::add, makeE<EVariable>(frame, 0), makeE<EVariable>(frame, 1))); + printInputExpression(os, *expr); + auto compiledExpr = compileExpression(*expr); - auto [tag, val] = runCompiledExpression(compiledExpr.get()); - value::ValueGuard guard(tag, val); + printCompiledExpression(os, *compiledExpr); - ASSERT_THAT(std::make_pair(tag, val), ValueEq(makeInt32(30))); + executeAndPrintVariation(os, *compiledExpr); } TEST_F(SBELocalBindTest, NestedBind1) { + auto& os = gctx->outStream(); + value::ViewOfValueAccessor slotAccessor; FrameId frame1 = 10; FrameId frame2 = 20; @@ -76,15 +84,17 @@ TEST_F(SBELocalBindTest, NestedBind1) { frame2, makeEs(makeC(makeInt32(20))), makeE<EPrimBinary>(EPrimBinary::Op::add, std::move(bindExpr), makeE<EVariable>(frame2, 0))); + printInputExpression(os, *expr); auto compiledExpr = compileExpression(*expr); - auto [tag, val] = runCompiledExpression(compiledExpr.get()); - value::ValueGuard guard(tag, val); + printCompiledExpression(os, *compiledExpr); - ASSERT_THAT(std::make_pair(tag, val), ValueEq(makeInt32(50))); + executeAndPrintVariation(os, *compiledExpr); } TEST_F(SBELocalBindTest, NestedBind2) { + auto& os = gctx->outStream(); + value::ViewOfValueAccessor slotAccessor; FrameId frame1 = 10; FrameId frame2 = 20; @@ -99,12 +109,12 @@ TEST_F(SBELocalBindTest, NestedBind2) { makeE<EPrimBinary>(EPrimBinary::Op::add, makeE<EVariable>(frame2, 0), makeE<EVariable>(frame2, 1))); + printInputExpression(os, *expr); auto compiledExpr = compileExpression(*expr); - auto [tag, val] = runCompiledExpression(compiledExpr.get()); - value::ValueGuard guard(tag, val); + printCompiledExpression(os, *compiledExpr); - ASSERT_THAT(std::make_pair(tag, val), ValueEq(makeInt32(60))); + executeAndPrintVariation(os, *compiledExpr); } } // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/expressions/sbe_prim_binary_test.cpp b/src/mongo/db/exec/sbe/expressions/sbe_prim_binary_test.cpp index d1cd3bb3c76..1fc72e4c786 100644 --- a/src/mongo/db/exec/sbe/expressions/sbe_prim_binary_test.cpp +++ b/src/mongo/db/exec/sbe/expressions/sbe_prim_binary_test.cpp @@ -28,10 +28,11 @@ */ #include "mongo/db/exec/sbe/expression_test_base.h" +#include "mongo/db/query/collation/collator_interface_mock.h" namespace mongo::sbe { -class SBEPrimBinaryTest : public EExpressionTestFixture { +class SBEPrimBinaryTest : public GoldenEExpressionTestFixture { public: std::unique_ptr<EExpression> makeBalancedBinaryExpr(EPrimBinary::Op op, int depth, @@ -46,75 +47,119 @@ public: return makeE<EVariable>(slotIds[offset]); } } -}; -TEST_F(SBEPrimBinaryTest, TruthTableAnd) { - GoldenTestContext gctx(&goldenTestConfigSbe); - gctx.printTestHeader(GoldenTestContext::HeaderFormat::Text); - auto& os = gctx.outStream(); + void runBinaryOpTest(std::ostream& os, + EPrimBinary::Op op, + std::vector<TypedValue>& testValues) { + value::ViewOfValueAccessor lhsAccessor; + value::ViewOfValueAccessor rhsAccessor; + auto lhsSlot = bindAccessor(&lhsAccessor); + auto rhsSlot = bindAccessor(&rhsAccessor); + + auto expr = + sbe::makeE<EPrimBinary>(op, makeE<EVariable>(lhsSlot), makeE<EVariable>(rhsSlot)); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify the operator table + for (auto lhs : testValues) + for (auto rhs : testValues) { + lhsAccessor.reset(lhs.first, lhs.second); + rhsAccessor.reset(rhs.first, rhs.second); + executeAndPrintVariation(os, *compiledExpr); + } + } - value::ViewOfValueAccessor lhsAccessor; - value::ViewOfValueAccessor rhsAccessor; + void runBinaryOpCollationTest(std::ostream& os, + EPrimBinary::Op op, + std::vector<TypedValue>& testValues, + std::vector<TypedValue>& collValues) { + value::ViewOfValueAccessor lhsAccessor; + value::ViewOfValueAccessor rhsAccessor; + value::ViewOfValueAccessor collAccessor; + + auto lhsSlot = bindAccessor(&lhsAccessor); + auto rhsSlot = bindAccessor(&rhsAccessor); + auto collSlot = bindAccessor(&collAccessor); + + auto expr = sbe::makeE<EPrimBinary>( + op, makeE<EVariable>(lhsSlot), makeE<EVariable>(rhsSlot), makeE<EVariable>(collSlot)); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify the operator table. + for (auto lhs : testValues) + for (auto rhs : testValues) + for (auto coll : collValues) { + lhsAccessor.reset(lhs.first, lhs.second); + rhsAccessor.reset(rhs.first, rhs.second); + collAccessor.reset(coll.first, coll.second); + executeAndPrintVariation(os, *compiledExpr); + } + } - auto lhsSlot = bindAccessor(&lhsAccessor); - auto rhsSlot = bindAccessor(&rhsAccessor); +protected: + std::vector<TypedValue> boolTestValues = {makeNothing(), makeBool(false), makeBool(true)}; + ValueVectorGuard boolTestValuesGuard{boolTestValues}; + + std::vector<TypedValue> numericTestValues = {makeNothing(), + makeInt32(12), + makeInt32(23), + makeInt64(123), + makeDouble(123.5), + value::makeCopyDecimal(Decimal128(223.5))}; + ValueVectorGuard numericTestValuesGuard{numericTestValues}; + + std::vector<TypedValue> mixedTestValues = {makeNothing(), + makeNull(), + makeBool(false), + makeBool(true), + makeInt32(12), + value::makeCopyDecimal(Decimal128(223.5)), + value::makeNewString("abc"_sd), + makeTimestamp(Timestamp(1668792433))}; + ValueVectorGuard mixedTestValuesGuard{mixedTestValues}; + + std::vector<TypedValue> stringTestValues = {makeNothing(), + value::makeNewString("abc"), + value::makeNewString("ABC"), + value::makeNewString("abcdefghijkop"), + value::makeNewString("ABCDEFGHIJKOP")}; + ValueVectorGuard stringTestValuesGuard{stringTestValues}; + + std::vector<TypedValue> collTestValues = { + makeNothing(), + value::makeCopyCollator( + CollatorInterfaceMock(CollatorInterfaceMock::MockType::kAlwaysEqual)), + value::makeCopyCollator( + CollatorInterfaceMock(CollatorInterfaceMock::MockType::kToLowerString))}; + ValueVectorGuard collTestValuesGuard{collTestValues}; +}; - auto expr = sbe::makeE<EPrimBinary>( - EPrimBinary::Op::logicAnd, makeE<EVariable>(lhsSlot), makeE<EVariable>(rhsSlot)); - printInputExpression(os, *expr); +/* Logic Operators */ - auto compiledExpr = compileExpression(*expr); - printCompiledExpression(os, *compiledExpr); - - // Verify the truth table - std::vector<TypedValue> testValues = {makeNothing(), makeBool(false), makeBool(true)}; - for (auto lhs : testValues) - for (auto rhs : testValues) { - lhsAccessor.reset(lhs.first, lhs.second); - rhsAccessor.reset(rhs.first, rhs.second); - executeAndPrintVariation(os, *compiledExpr); - } +TEST_F(SBEPrimBinaryTest, TruthTableAnd) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::logicAnd, boolTestValues); } TEST_F(SBEPrimBinaryTest, TruthTableOr) { - GoldenTestContext gctx(&goldenTestConfigSbe); - gctx.printTestHeader(GoldenTestContext::HeaderFormat::Text); - auto& os = gctx.outStream(); - - value::ViewOfValueAccessor lhsAccessor; - value::ViewOfValueAccessor rhsAccessor; - - auto lhsSlot = bindAccessor(&lhsAccessor); - auto rhsSlot = bindAccessor(&rhsAccessor); - - auto expr = sbe::makeE<EPrimBinary>( - EPrimBinary::Op::logicOr, makeE<EVariable>(lhsSlot), makeE<EVariable>(rhsSlot)); - printInputExpression(os, *expr); - - auto compiledExpr = compileExpression(*expr); - printCompiledExpression(os, *compiledExpr); - - // Verify the truth table - std::vector<TypedValue> testValues = {makeNothing(), makeBool(false), makeBool(true)}; - for (auto lhs : testValues) - for (auto rhs : testValues) { - lhsAccessor.reset(lhs.first, lhs.second); - rhsAccessor.reset(rhs.first, rhs.second); - executeAndPrintVariation(os, *compiledExpr); - } + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::logicOr, boolTestValues); } TEST_F(SBEPrimBinaryTest, BalancedAnd) { - GoldenTestContext gctx(&goldenTestConfigSbe); - gctx.printTestHeader(GoldenTestContext::HeaderFormat::Text); - auto& os = gctx.outStream(); + auto& os = gctx->outStream(); std::vector<std::unique_ptr<value::ViewOfValueAccessor>> accessors; value::SlotVector slotIds; int depth = 3; int numSlots = 1 << depth; - for (int i = 0; i < numSlots; i++) { accessors.emplace_back(std::make_unique<value::ViewOfValueAccessor>()); accessors.back()->reset(value::TypeTags::Boolean, value::bitcastFrom<bool>(true)); @@ -127,7 +172,7 @@ TEST_F(SBEPrimBinaryTest, BalancedAnd) { auto compiledExpr = compileExpression(*expr); printCompiledExpression(os, *compiledExpr); - // All values are true + // All values are true. { auto [tag, val] = runCompiledExpression(compiledExpr.get()); value::ValueGuard guard(tag, val); @@ -136,7 +181,7 @@ TEST_F(SBEPrimBinaryTest, BalancedAnd) { ASSERT_THAT(std::make_pair(tag, val), ValueEq(expected)); } - // One of the values is false + // One of the values is false. for (int falsePosition = 0; falsePosition < numSlots; falsePosition++) { accessors[falsePosition]->reset(value::TypeTags::Boolean, value::bitcastFrom<bool>(false)); @@ -149,7 +194,7 @@ TEST_F(SBEPrimBinaryTest, BalancedAnd) { accessors[falsePosition]->reset(value::TypeTags::Boolean, value::bitcastFrom<bool>(true)); } - // One of the values is true and one is nothing + // One of the values is true and one is nothing. for (int nothingPosition = 0; nothingPosition < numSlots; nothingPosition++) for (int falsePosition = 0; falsePosition < numSlots; falsePosition++) { if (nothingPosition == falsePosition) @@ -174,11 +219,8 @@ TEST_F(SBEPrimBinaryTest, BalancedAnd) { } } - TEST_F(SBEPrimBinaryTest, BalancedOr) { - GoldenTestContext gctx(&goldenTestConfigSbe); - gctx.printTestHeader(GoldenTestContext::HeaderFormat::Text); - auto& os = gctx.outStream(); + auto& os = gctx->outStream(); std::vector<std::unique_ptr<value::ViewOfValueAccessor>> accessors; value::SlotVector slotIds; @@ -198,7 +240,7 @@ TEST_F(SBEPrimBinaryTest, BalancedOr) { auto compiledExpr = compileExpression(*expr); printCompiledExpression(os, *compiledExpr); - // All values are false + // All values are false. { auto [tag, val] = runCompiledExpression(compiledExpr.get()); value::ValueGuard guard(tag, val); @@ -207,7 +249,7 @@ TEST_F(SBEPrimBinaryTest, BalancedOr) { ASSERT_THAT(std::make_pair(tag, val), ValueEq(expected)); } - // One of the values is true + // One of the values is true. for (int truePosition = 0; truePosition < numSlots; truePosition++) { accessors[truePosition]->reset(value::TypeTags::Boolean, value::bitcastFrom<bool>(true)); @@ -220,7 +262,7 @@ TEST_F(SBEPrimBinaryTest, BalancedOr) { accessors[truePosition]->reset(value::TypeTags::Boolean, value::bitcastFrom<bool>(false)); } - // One of the values is true and one is nothing + // One of the values is true and one is nothing. for (int nothingPosition = 0; nothingPosition < numSlots; nothingPosition++) for (int truePosition = 0; truePosition < numSlots; truePosition++) { if (nothingPosition == truePosition) @@ -245,4 +287,195 @@ TEST_F(SBEPrimBinaryTest, BalancedOr) { } } +/* Arithmetic operators - Numeric */ +TEST_F(SBEPrimBinaryTest, AddNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::add, numericTestValues); +} + +TEST_F(SBEPrimBinaryTest, SubNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::sub, numericTestValues); +} + +TEST_F(SBEPrimBinaryTest, MulNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::mul, numericTestValues); +} + +TEST_F(SBEPrimBinaryTest, DivNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::div, numericTestValues); +} + +/* Arithmetic operators - Mixed */ + +TEST_F(SBEPrimBinaryTest, AddMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::add, mixedTestValues); +} + +TEST_F(SBEPrimBinaryTest, SubMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::sub, mixedTestValues); +} + +TEST_F(SBEPrimBinaryTest, MulMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::mul, mixedTestValues); +} + +TEST_F(SBEPrimBinaryTest, DivMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::div, mixedTestValues); +} + +/* Comparison operators - Numeric*/ + +TEST_F(SBEPrimBinaryTest, EqNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::eq, numericTestValues); +} + +TEST_F(SBEPrimBinaryTest, NeqNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::neq, numericTestValues); +} + +TEST_F(SBEPrimBinaryTest, LessNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::less, numericTestValues); +} + +TEST_F(SBEPrimBinaryTest, LessEqMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::lessEq, mixedTestValues); +} + +TEST_F(SBEPrimBinaryTest, GreaterNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::greater, numericTestValues); +} + +TEST_F(SBEPrimBinaryTest, GreaterEqNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::greaterEq, numericTestValues); +} + +TEST_F(SBEPrimBinaryTest, Cmp3wNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::cmp3w, numericTestValues); +} + +/* Comparison operators - Mixed */ + +TEST_F(SBEPrimBinaryTest, EqMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::eq, mixedTestValues); +} + +TEST_F(SBEPrimBinaryTest, NeqMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::neq, mixedTestValues); +} + +TEST_F(SBEPrimBinaryTest, LessMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::less, mixedTestValues); +} + +TEST_F(SBEPrimBinaryTest, LessEqNumeric) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::lessEq, numericTestValues); +} + +TEST_F(SBEPrimBinaryTest, GreaterMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::greater, mixedTestValues); +} + +TEST_F(SBEPrimBinaryTest, GreaterEqMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::greaterEq, mixedTestValues); +} + +TEST_F(SBEPrimBinaryTest, Cmp3wMixed) { + auto& os = gctx->outStream(); + runBinaryOpTest(os, EPrimBinary::Op::cmp3w, mixedTestValues); +} + +/* Comparison operators - String */ + +TEST_F(SBEPrimBinaryTest, EqString) { + auto& os = gctx->outStream(); + runBinaryOpCollationTest(os, EPrimBinary::Op::eq, stringTestValues, collTestValues); +} + +TEST_F(SBEPrimBinaryTest, NeqString) { + auto& os = gctx->outStream(); + runBinaryOpCollationTest(os, EPrimBinary::Op::neq, stringTestValues, collTestValues); +} + +TEST_F(SBEPrimBinaryTest, LessString) { + auto& os = gctx->outStream(); + runBinaryOpCollationTest(os, EPrimBinary::Op::less, stringTestValues, collTestValues); +} + +TEST_F(SBEPrimBinaryTest, LessEqString) { + auto& os = gctx->outStream(); + runBinaryOpCollationTest(os, EPrimBinary::Op::lessEq, stringTestValues, collTestValues); +} + +TEST_F(SBEPrimBinaryTest, GreaterString) { + auto& os = gctx->outStream(); + runBinaryOpCollationTest(os, EPrimBinary::Op::greater, stringTestValues, collTestValues); +} + +TEST_F(SBEPrimBinaryTest, GreaterEqString) { + auto& os = gctx->outStream(); + runBinaryOpCollationTest(os, EPrimBinary::Op::greaterEq, stringTestValues, collTestValues); +} + +TEST_F(SBEPrimBinaryTest, Cmp3wString) { + auto& os = gctx->outStream(); + runBinaryOpCollationTest(os, EPrimBinary::Op::cmp3w, stringTestValues, collTestValues); +} + +/* Misc operators */ + +TEST_F(SBEPrimBinaryTest, FillEmpty) { + auto& os = gctx->outStream(); + std::vector<TypedValue> testValues = { + makeNothing(), makeNull(), makeBool(false), makeBool(true)}; + runBinaryOpTest(os, EPrimBinary::Op::fillEmpty, testValues); +} + +TEST_F(SBEPrimBinaryTest, FillEmptyWithConstant) { + auto& os = gctx->outStream(); + + std::vector<TypedValue> testValues = { + makeNothing(), makeNull(), makeBool(true), makeBool(true)}; + for (auto rhs : testValues) { + + os << "== VARIATION rhs constant: " << rhs << std::endl; + + value::ViewOfValueAccessor lhsAccessor; + auto lhsSlot = bindAccessor(&lhsAccessor); + + auto expr = sbe::makeE<EPrimBinary>( + EPrimBinary::Op::fillEmpty, makeE<EVariable>(lhsSlot), makeC(rhs)); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify the combination table. + for (auto lhs : testValues) { + + lhsAccessor.reset(lhs.first, lhs.second); + executeAndPrintVariation(os, *compiledExpr); + } + } +} + } // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/expressions/sbe_prim_unary_test.cpp b/src/mongo/db/exec/sbe/expressions/sbe_prim_unary_test.cpp new file mode 100644 index 00000000000..2e614904992 --- /dev/null +++ b/src/mongo/db/exec/sbe/expressions/sbe_prim_unary_test.cpp @@ -0,0 +1,99 @@ +/** + * Copyright (C) 2022-present MongoDB, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the Server Side Public License, version 1, + * as published by MongoDB, Inc. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * Server Side Public License for more details. + * + * You should have received a copy of the Server Side Public License + * along with this program. If not, see + * <http://www.mongodb.com/licensing/server-side-public-license>. + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the Server Side Public License in all respects for + * all of the code used other than as permitted herein. If you modify file(s) + * with this exception, you may extend this exception to your version of the + * file(s), but you are not obligated to do so. If you do not wish to do so, + * delete this exception statement from your version. If you delete this + * exception statement from all source files in the program, then also delete + * it in the license file. + */ + +#include "mongo/db/exec/sbe/expression_test_base.h" + +namespace mongo::sbe { + +class SBEPrimUnaryTest : public GoldenEExpressionTestFixture { +public: + void runUnaryOpTest(std::ostream& os, EPrimUnary::Op op, std::vector<TypedValue>& testValues) { + value::ViewOfValueAccessor lhsAccessor; + + auto lhsSlot = bindAccessor(&lhsAccessor); + + auto expr = sbe::makeE<EPrimUnary>(op, makeE<EVariable>(lhsSlot)); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + // Verify the operator table + for (auto lhs : testValues) { + lhsAccessor.reset(lhs.first, lhs.second); + executeAndPrintVariation(os, *compiledExpr); + } + } + +protected: + std::vector<TypedValue> boolTestValues = {makeNothing(), makeBool(false), makeBool(true)}; + ValueVectorGuard boolTestValuesGuard{boolTestValues}; + + std::vector<TypedValue> numericTestValues = {makeNothing(), + makeInt32(0), + makeInt32(12), + makeInt32(23), + makeInt64(123), + makeDouble(123.5), + value::makeCopyDecimal(Decimal128(223.5))}; + ValueVectorGuard numericTestValuesGuard{numericTestValues}; + + std::vector<TypedValue> mixedTestValues = {makeNothing(), + makeNull(), + makeBool(false), + makeBool(true), + makeInt32(12), + value::makeCopyDecimal(Decimal128(223.5)), + value::makeNewString("abc"_sd), + makeTimestamp(Timestamp(1668792433))}; + ValueVectorGuard mixedTestValuesGuard{mixedTestValues}; +}; + +TEST_F(SBEPrimUnaryTest, LogicNotBool) { + auto& os = gctx->outStream(); + runUnaryOpTest(os, EPrimUnary::Op::logicNot, boolTestValues); +} + +TEST_F(SBEPrimUnaryTest, LogicNotMixed) { + auto& os = gctx->outStream(); + runUnaryOpTest(os, EPrimUnary::Op::logicNot, mixedTestValues); +} + + +TEST_F(SBEPrimUnaryTest, NegateNumeric) { + auto& os = gctx->outStream(); + runUnaryOpTest(os, EPrimUnary::Op::negate, numericTestValues); +} + +TEST_F(SBEPrimUnaryTest, NegateMixed) { + auto& os = gctx->outStream(); + runUnaryOpTest(os, EPrimUnary::Op::negate, mixedTestValues); +} + +} // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/expressions/sbe_variable_test.cpp b/src/mongo/db/exec/sbe/expressions/sbe_variable_test.cpp new file mode 100644 index 00000000000..37bf0ee091f --- /dev/null +++ b/src/mongo/db/exec/sbe/expressions/sbe_variable_test.cpp @@ -0,0 +1,92 @@ +/** + * Copyright (C) 2022-present MongoDB, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the Server Side Public License, version 1, + * as published by MongoDB, Inc. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * Server Side Public License for more details. + * + * You should have received a copy of the Server Side Public License + * along with this program. If not, see + * <http://www.mongodb.com/licensing/server-side-public-license>. + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the Server Side Public License in all respects for + * all of the code used other than as permitted herein. If you modify file(s) + * with this exception, you may extend this exception to your version of the + * file(s), but you are not obligated to do so. If you do not wish to do so, + * delete this exception statement from your version. If you delete this + * exception statement from all source files in the program, then also delete + * it in the license file. + */ + +#include "mongo/db/exec/sbe/expression_test_base.h" +#include "mongo/db/exec/sbe/values/bson.h" + +namespace mongo::sbe { + +using SBEVariableTest = GoldenEExpressionTestFixture; + +TEST_F(SBEVariableTest, SlotVariable) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor slotAccessor; + auto slotId = bindAccessor(&slotAccessor); + auto expr = makeE<EVariable>(slotId); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + std::vector<TypedValue> testValues = {makeNothing(), makeBool(true), makeInt32(123)}; + for (auto p : testValues) { + slotAccessor.reset(p.first, p.second); + + executeAndPrintVariation(os, *compiledExpr); + } +} + +TEST_F(SBEVariableTest, LocalVariable) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor slotAccessor; + FrameId frame = 10; + auto expr = sbe::makeE<ELocalBind>( + frame, + makeEs(makeC(value::makeNewString("abcdeghijklmnop"_sd))), + makeE<EFunction>("newArray"_sd, + makeEs(makeE<EVariable>(frame, 0), makeE<EVariable>(frame, 0)))); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + executeAndPrintVariation(os, *compiledExpr); +} + +TEST_F(SBEVariableTest, LocalVariableMove) { + auto& os = gctx->outStream(); + + value::ViewOfValueAccessor slotAccessor; + FrameId frame = 10; + auto expr = sbe::makeE<ELocalBind>(frame, + makeEs(makeC(value::makeNewString("abcdeghijklmnop"_sd))), + makeE<EFunction>("newArray"_sd, + makeEs(makeE<EVariable>(frame, 0, true), + makeE<EVariable>(frame, 0, true)))); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); + + executeAndPrintVariation(os, *compiledExpr); +} + +} // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/sbe_numeric_convert_test.cpp b/src/mongo/db/exec/sbe/sbe_numeric_convert_test.cpp index 2dda3e73a3a..35072243158 100644 --- a/src/mongo/db/exec/sbe/sbe_numeric_convert_test.cpp +++ b/src/mongo/db/exec/sbe/sbe_numeric_convert_test.cpp @@ -86,6 +86,19 @@ protected: } }; +TEST_F(SBENumericTest, Compile) { + GoldenTestContext gctx(&goldenTestConfigSbe); + gctx.printTestHeader(GoldenTestContext::HeaderFormat::Text); + auto& os = gctx.outStream(); + + auto expr = test_detail::makeEFromNumber( + Decimal128(123), value::TypeTags::NumberDecimal, value::TypeTags::NumberInt64); + printInputExpression(os, *expr); + + auto compiledExpr = compileExpression(*expr); + printCompiledExpression(os, *compiledExpr); +} + TEST_F(SBENumericTest, Int32ToInt64) { assertConversion(int32_t{-2147483648}, int64_t{-2147483648}, diff --git a/src/mongo/db/exec/sbe/util/print_options.h b/src/mongo/db/exec/sbe/util/print_options.h index cb6a58d6a0e..00f42b31fdb 100644 --- a/src/mongo/db/exec/sbe/util/print_options.h +++ b/src/mongo/db/exec/sbe/util/print_options.h @@ -41,6 +41,7 @@ public: static constexpr size_t kDefaultBinDataMaxDisplayLength = 80; static constexpr size_t kDefaultArrayObjectOrNestingMaxDepth = 10; static constexpr size_t kDefaultUseTagForAmbiguousValues = false; + static constexpr size_t kNormalizeOutput = false; size_t stringMaxDisplayLength() const { return _stringMaxDisplayLength; @@ -78,11 +79,25 @@ public: return *this; } + bool normalizeOutput() const { + return _normalizeOutput; + } + + /** + * Sets whether the output should be normalized. A normalized output will be + * stable, determinisitc and platform independent. + */ + PrintOptions& normalizeOutput(bool value) { + _normalizeOutput = value; + return *this; + } + private: size_t _stringMaxDisplayLength = kDefaultStringMaxDisplayLength; size_t _binDataMaxDisplayLength = kDefaultBinDataMaxDisplayLength; size_t _arrayObjectOrNestingMaxDepth = kDefaultArrayObjectOrNestingMaxDepth; bool _useTagForAmbiguousValues = kDefaultUseTagForAmbiguousValues; + bool _normalizeOutput = kNormalizeOutput; }; } // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/values/value_printer.cpp b/src/mongo/db/exec/sbe/values/value_printer.cpp index e4f099a9d01..9673d20a304 100644 --- a/src/mongo/db/exec/sbe/values/value_printer.cpp +++ b/src/mongo/db/exec/sbe/values/value_printer.cpp @@ -26,10 +26,13 @@ * exception statement from all source files in the program, then also delete * it in the license file. */ -#include "mongo/db/exec/sbe/values/value_printer.h" +#include <algorithm> +#include <boost/format.hpp> + #include "mongo/db/exec/sbe/values/makeobj_spec.h" #include "mongo/db/exec/sbe/values/sort_spec.h" #include "mongo/db/exec/sbe/values/value.h" +#include "mongo/db/exec/sbe/values/value_printer.h" #include "mongo/platform/basic.h" #include "mongo/util/pcre_util.h" @@ -222,6 +225,45 @@ void ValuePrinter<T>::writeArrayToStream(TypeTags tag, Value val, size_t depth) } template <typename T> +void ValuePrinter<T>::writeSortedArraySetToStream(TypeTags tag, Value val, size_t depth) { + std::vector<std::pair<TypeTags, Value>> items; + for (auto ae = ArrayEnumerator{tag, val}; !ae.atEnd(); ae.advance()) { + items.push_back(ae.getViewOfValue()); + } + std::sort(items.begin(), + items.end(), + [&](std::pair<TypeTags, Value> lhs, std::pair<TypeTags, Value> rhs) { + auto [tagCmp, valCmp] = + compareValue(lhs.first, lhs.second, rhs.first, rhs.second); + return tagCmp == TypeTags::NumberInt32 && bitcastTo<int32_t>(valCmp) < 0; + }); + stream << '['; + auto shouldTruncate = true; + size_t iter = 0; + if (auto it = items.begin(); it != items.end()) { + while (iter < options.arrayObjectOrNestingMaxDepth() && + depth < options.arrayObjectOrNestingMaxDepth()) { + auto [aeTag, aeVal] = *it; + if (aeTag == TypeTags::Array || aeTag == TypeTags::Object) { + ++depth; + } + writeValueToStream(aeTag, aeVal, depth); + it++; + if (it == items.end()) { + shouldTruncate = false; + break; + } + stream << ", "; + ++iter; + } + if (shouldTruncate || depth > options.arrayObjectOrNestingMaxDepth()) { + stream << "..."; + } + } + stream << ']'; +} + +template <typename T> void ValuePrinter<T>::writeObjectToStream(TypeTags tag, Value val, size_t depth) { stream << '{'; auto shouldTruncate = true; @@ -289,6 +331,14 @@ void ValuePrinter<T>::writeBsonRegexToStream(const BsonRegex& regex) { } template <typename T> +void ValuePrinter<T>::writeNormalizedDouble(double value) { + std::stringstream ss; + ss.precision(std::numeric_limits<double>::max_digits10); + ss << (boost::format("%f") % value); + stream << ss.str(); +} + +template <typename T> void ValuePrinter<T>::writeValueToStream(TypeTags tag, Value val, size_t depth) { switch (tag) { case TypeTags::NumberInt32: @@ -301,7 +351,11 @@ void ValuePrinter<T>::writeValueToStream(TypeTags tag, Value val, size_t depth) } break; case TypeTags::NumberDouble: - stream << bitcastTo<double>(val); + if (options.normalizeOutput()) { + writeNormalizedDouble(bitcastTo<double>(val)); + } else { + stream << bitcastTo<double>(val); + } if (options.useTagForAmbiguousValues()) { stream << "L"; } @@ -343,10 +397,16 @@ void ValuePrinter<T>::writeValueToStream(TypeTags tag, Value val, size_t depth) stream << ')'; break; case TypeTags::Array: - case TypeTags::ArraySet: case TypeTags::bsonArray: writeArrayToStream(tag, val, depth); break; + case TypeTags::ArraySet: + if (options.normalizeOutput()) { + writeSortedArraySetToStream(tag, val, depth); + } else { + writeArrayToStream(tag, val, depth); + } + break; case TypeTags::Object: case TypeTags::bsonObject: writeObjectToStream(tag, val, depth); @@ -400,15 +460,8 @@ void ValuePrinter<T>::writeValueToStream(TypeTags tag, Value val, size_t depth) break; } case TypeTags::Timestamp: { - if (options.useTagForAmbiguousValues()) { - writeTagToStream(tag); - stream << "("; - } Timestamp ts{bitcastTo<uint64_t>(val)}; stream << ts.toString(); - if (options.useTagForAmbiguousValues()) { - stream << ")"; - } break; } case TypeTags::pcreRegex: { diff --git a/src/mongo/db/exec/sbe/values/value_printer.h b/src/mongo/db/exec/sbe/values/value_printer.h index 337cc252827..42b5f99ab86 100644 --- a/src/mongo/db/exec/sbe/values/value_printer.h +++ b/src/mongo/db/exec/sbe/values/value_printer.h @@ -66,11 +66,13 @@ public: void writeTagToStream(TypeTags tag); void writeStringDataToStream(StringData sd, bool isJavaScript = false); void writeArrayToStream(TypeTags tag, Value val, size_t depth = 1); + void writeSortedArraySetToStream(TypeTags tag, Value val, size_t depth = 1); void writeObjectToStream(TypeTags tag, Value val, size_t depth = 1); void writeObjectToStream(const BSONObj& obj); void writeObjectIdToStream(TypeTags tag, Value val); void writeCollatorToStream(const CollatorInterface* collator); void writeBsonRegexToStream(const BsonRegex& regex); + void writeNormalizedDouble(double value); void writeValueToStream(TypeTags tag, Value val, size_t depth = 1); public: diff --git a/src/mongo/db/exec/sbe/vm/vm.cpp b/src/mongo/db/exec/sbe/vm/vm.cpp index f601579a48e..09c0b421612 100644 --- a/src/mongo/db/exec/sbe/vm/vm.cpp +++ b/src/mongo/db/exec/sbe/vm/vm.cpp @@ -5022,6 +5022,224 @@ FastTuple<bool, value::TypeTags, value::Value> ByteCode::dispatchBuiltin(Builtin MONGO_UNREACHABLE; } + +std::string builtinToString(Builtin b) { + switch (b) { + case Builtin::split: + return "split"; + case Builtin::regexMatch: + return "regexMatch"; + case Builtin::replaceOne: + return "replaceOne"; + case Builtin::dateDiff: + return "dateDiff"; + case Builtin::dateParts: + return "dateParts"; + case Builtin::dateToParts: + return "dateToParts"; + case Builtin::isoDateToParts: + return "isoDateToParts"; + case Builtin::dayOfYear: + return "dayOfYear"; + case Builtin::dayOfMonth: + return "dayOfMonth"; + case Builtin::dayOfWeek: + return "dayOfWeek"; + case Builtin::datePartsWeekYear: + return "datePartsWeekYear"; + case Builtin::dropFields: + return "dropFields"; + case Builtin::newArray: + return "newArray"; + case Builtin::keepFields: + return "keepFields"; + case Builtin::newArrayFromRange: + return "newArrayFromRange"; + case Builtin::newObj: + return "newObj"; + case Builtin::ksToString: + return "ksToString"; + case Builtin::newKs: + return "newKs"; + case Builtin::collNewKs: + return "collNewKs"; + case Builtin::abs: + return "abs"; + case Builtin::ceil: + return "ceil"; + case Builtin::floor: + return "floor"; + case Builtin::trunc: + return "trunc"; + case Builtin::exp: + return "exp"; + case Builtin::ln: + return "ln"; + case Builtin::log10: + return "log10"; + case Builtin::sqrt: + return "sqrt"; + case Builtin::addToArray: + return "addToArray"; + case Builtin::addToArrayCapped: + return "addToArrayCapped"; + case Builtin::mergeObjects: + return "mergeObjects"; + case Builtin::addToSet: + return "addToSet"; + case Builtin::addToSetCapped: + return "addToSetCapped"; + case Builtin::collAddToSet: + return "collAddToSet"; + case Builtin::collAddToSetCapped: + return "collAddToSetCapped"; + case Builtin::doubleDoubleSum: + return "doubleDoubleSum"; + case Builtin::aggDoubleDoubleSum: + return "aggDoubleDoubleSum"; + case Builtin::doubleDoubleSumFinalize: + return "doubleDoubleSumFinalize"; + case Builtin::doubleDoublePartialSumFinalize: + return "doubleDoublePartialSumFinalize"; + case Builtin::aggStdDev: + return "aggStdDev"; + case Builtin::stdDevPopFinalize: + return "stdDevPopFinalize"; + case Builtin::stdDevSampFinalize: + return "stdDevSampFinalize"; + case Builtin::bitTestZero: + return "bitTestZero"; + case Builtin::bitTestMask: + return "bitTestMask"; + case Builtin::bitTestPosition: + return "bitTestPosition"; + case Builtin::bsonSize: + return "bsonSize"; + case Builtin::toUpper: + return "toUpper"; + case Builtin::toLower: + return "toLower"; + case Builtin::coerceToString: + return "coerceToString"; + case Builtin::concat: + return "concat"; + case Builtin::concatArrays: + return "concatArrays"; + case Builtin::acos: + return "acos"; + case Builtin::acosh: + return "acosh"; + case Builtin::asin: + return "asin"; + case Builtin::asinh: + return "asinh"; + case Builtin::atan: + return "atan"; + case Builtin::atanh: + return "atanh"; + case Builtin::atan2: + return "atan2"; + case Builtin::cos: + return "cos"; + case Builtin::cosh: + return "cosh"; + case Builtin::degreesToRadians: + return "degreesToRadians"; + case Builtin::radiansToDegrees: + return "radiansToDegrees"; + case Builtin::sin: + return "sin"; + case Builtin::sinh: + return "sinh"; + case Builtin::tan: + return "tan"; + case Builtin::tanh: + return "tanh"; + case Builtin::round: + return "round"; + case Builtin::isMember: + return "isMember"; + case Builtin::collIsMember: + return "collIsMember"; + case Builtin::indexOfBytes: + return "indexOfBytes"; + case Builtin::indexOfCP: + return "indexOfCP"; + case Builtin::isDayOfWeek: + return "isDayOfWeek"; + case Builtin::isTimeUnit: + return "isTimeUnit"; + case Builtin::isTimezone: + return "isTimezone"; + case Builtin::setUnion: + return "setUnion"; + case Builtin::setIntersection: + return "setIntersection"; + case Builtin::setDifference: + return "setDifference"; + case Builtin::setEquals: + return "setEquals"; + case Builtin::collSetUnion: + return "collSetUnion"; + case Builtin::collSetIntersection: + return "collSetIntersection"; + case Builtin::collSetDifference: + return "collSetDifference"; + case Builtin::collSetEquals: + return "collSetEquals"; + case Builtin::runJsPredicate: + return "runJsPredicate"; + case Builtin::regexCompile: + return "regexCompile"; + case Builtin::regexFind: + return "regexFind"; + case Builtin::regexFindAll: + return "regexFindAll"; + case Builtin::shardFilter: + return "shardFilter"; + case Builtin::shardHash: + return "shardHash"; + case Builtin::extractSubArray: + return "extractSubArray"; + case Builtin::isArrayEmpty: + return "isArrayEmpty"; + case Builtin::reverseArray: + return "reverseArray"; + case Builtin::sortArray: + return "sortArray"; + case Builtin::dateAdd: + return "dateAdd"; + case Builtin::hasNullBytes: + return "hasNullBytes"; + case Builtin::getRegexPattern: + return "getRegexPattern"; + case Builtin::getRegexFlags: + return "getRegexFlags"; + case Builtin::hash: + return "hash"; + case Builtin::ftsMatch: + return "ftsMatch"; + case Builtin::generateSortKey: + return "generateSortKey"; + case Builtin::makeBsonObj: + return "makeBsonObj"; + case Builtin::tsSecond: + return "tsSecond"; + case Builtin::tsIncrement: + return "tsIncrement"; + case Builtin::typeMatch: + return "typeMatch"; + case Builtin::dateTrunc: + return "dateTrunc"; + case Builtin::internalLeast: + return "internalLeast"; + case Builtin::internalGreatest: + return "internalGreatest"; + default: + MONGO_UNREACHABLE; + } +} + MONGO_COMPILER_NORETURN void reportSwapFailure(); void ByteCode::swapStack() { diff --git a/src/mongo/db/exec/sbe/vm/vm.h b/src/mongo/db/exec/sbe/vm/vm.h index d50a52b4e56..641f00dd95c 100644 --- a/src/mongo/db/exec/sbe/vm/vm.h +++ b/src/mongo/db/exec/sbe/vm/vm.h @@ -692,6 +692,8 @@ enum class Builtin : uint8_t { internalGreatest, // helper functions for computation of sort keys }; +std::string builtinToString(Builtin b); + /** * This enum defines indices into an 'Array' that returns the partial sum result when 'needsMerge' * is requested. diff --git a/src/mongo/db/exec/sbe/vm/vm_printer.cpp b/src/mongo/db/exec/sbe/vm/vm_printer.cpp index 572780bd28f..2ed13999339 100644 --- a/src/mongo/db/exec/sbe/vm/vm_printer.cpp +++ b/src/mongo/db/exec/sbe/vm/vm_printer.cpp @@ -29,6 +29,7 @@ #include <boost/format.hpp> +#include "mongo/db/exec/sbe/values/value_printer.h" #include "mongo/db/exec/sbe/vm/vm.h" #include "mongo/db/exec/sbe/vm/vm_printer.h" #include "mongo/platform/basic.h" @@ -176,6 +177,13 @@ public: case Instruction::ret: { break; } + case Instruction::allocStack: { + auto size = readFromMemory<uint32_t>(pcPointer); + pcPointer += sizeof(size); + os << "size:" << size; + break; + } + // Instructions with 2 arguments and a collator. case Instruction::collLess: case Instruction::collLessEq: @@ -302,7 +310,10 @@ public: pcPointer += sizeof(tag); auto val = readFromMemory<value::Value>(pcPointer); pcPointer += sizeof(val); - os << "value: " << std::make_pair(tag, val); + os << "value: "; + value::ValuePrinters::make( + os, PrintOptions().useTagForAmbiguousValues(true).normalizeOutput(true)) + .writeValueToStream(tag, val); break; } case Instruction::pushAccessVal: @@ -344,7 +355,7 @@ public: arity = readFromMemory<SmallArityType>(pcPointer); pcPointer += sizeof(SmallArityType); } - os << "f: " << static_cast<uint8_t>(f) << ", arity: " << arity; + os << "f: " << builtinToString(f) << ", arity: " << arity; break; } case Instruction::dateTruncImm: { diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_constant_test/sbe_constants.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_constant_test/sbe_constants.txt new file mode 100644 index 00000000000..a8c6ac8cd70 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_constant_test/sbe_constants.txt @@ -0,0 +1,129 @@ +# Golden test output of SBEConstantTest/SbeConstants +-- INPUT EXPRESSION: +Nothing + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: Nothing); + + +-- INPUT EXPRESSION: +null + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: null); + + +-- INPUT EXPRESSION: +true + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: true); + + +-- INPUT EXPRESSION: +123 + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: 123); + + +-- INPUT EXPRESSION: +123ll + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: 123ll); + + +-- INPUT EXPRESSION: +123.000000L + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: 123.000000L); + + +-- INPUT EXPRESSION: +minKey + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: minKey); + + +-- INPUT EXPRESSION: +maxKey + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: maxKey); + + +-- INPUT EXPRESSION: +NumberDecimal(123.000000000000) + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: NumberDecimal(123.000000000000)); + + +-- INPUT EXPRESSION: +"abc" + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: "abc"); + + +-- INPUT EXPRESSION: +"abcdefghijklmnop" + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: "abcdefghijklmnop"); + + +-- INPUT EXPRESSION: +RecordId(123) + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: RecordId(123)); + + +-- INPUT EXPRESSION: +ObjectId("000102030405060708090a0b") + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: ObjectId("000102030405060708090a0b")); + + +-- INPUT EXPRESSION: +[1, 2, 3] + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: [1, 2, 3]); + + +-- INPUT EXPRESSION: +[1, 2, 3] + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: [1, 2, 3]); + + +-- INPUT EXPRESSION: +{"a" : 1, "b" : 2} + +-- COMPILED EXPRESSION: +[0x0000-0x000a] +0x0000: pushConstVal(value: {"a" : 1, "b" : 2}); + + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_fail_test/fail_with_add_decimal.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_fail_test/fail_with_add_decimal.txt new file mode 100644 index 00000000000..7b3b80bd9e1 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_fail_test/fail_with_add_decimal.txt @@ -0,0 +1,16 @@ +# Golden test output of SBEFailTest/FailWithAddDecimal +-- INPUT EXPRESSION: +(NumberDecimal(123) + fail(2, "test")) + +-- COMPILED EXPRESSION: +[0x0000-0x0022] +0x0000: pushConstVal(value: NumberDecimal(123)); +0x000a: pushConstVal(value: 2ll); +0x0014: pushConstVal(value: "test"); +0x001e: fail(); +0x001f: add(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +EXCEPTION: BadValue: test + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_fail_test/fail_with_local_bind.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_fail_test/fail_with_local_bind.txt new file mode 100644 index 00000000000..365b40a9ac5 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_fail_test/fail_with_local_bind.txt @@ -0,0 +1,22 @@ +# Golden test output of SBEFailTest/FailWithLocalBind +-- INPUT EXPRESSION: + + let [ + l10.0 = NumberDecimal(123) + ] + in fail(2, "test") + + +-- COMPILED EXPRESSION: +[0x0000-0x0021] +0x0000: pushConstVal(value: NumberDecimal(123)); +0x000a: pushConstVal(value: 2ll); +0x0014: pushConstVal(value: "test"); +0x001e: fail(); +0x001f: swap(); +0x0020: pop(); + + +-- EXECUTE VARIATION: +EXCEPTION: BadValue: test + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_fail_test/simple_fail.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_fail_test/simple_fail.txt new file mode 100644 index 00000000000..eeffc2d4582 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_fail_test/simple_fail.txt @@ -0,0 +1,14 @@ +# Golden test output of SBEFailTest/SimpleFail +-- INPUT EXPRESSION: +fail(2, "test") + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushConstVal(value: 2ll); +0x000a: pushConstVal(value: "test"); +0x0014: fail(); + + +-- EXECUTE VARIATION: +EXCEPTION: BadValue: test + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_fill_empty.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_fill_empty.txt new file mode 100644 index 00000000000..dc27e00ba75 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_fill_empty.txt @@ -0,0 +1,58 @@ +# Golden test output of SBEIfTest/IfWithFillEmpty +-- INPUT EXPRESSION: + + if (s1 ?: s2) + then "then" + else "else" + + +-- COMPILED EXPRESSION: +[0x0000-0x0040] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: jmpNothing(target: 0x0013); +0x000e: jmp(target: 0x001d); +0x0013: pop(); +0x0014: pushAccessVal(accessor: <accessor>); +0x001d: jmpNothing(target: 0x0040); +0x0022: jmpTrue(target: 0x0036); +0x0027: pushConstVal(value: "else"); +0x0031: jmp(target: 0x0040); +0x0036: pushConstVal(value: "then"); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: "then" + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: "then" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: "then" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: "then" + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_logic_and.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_logic_and.txt new file mode 100644 index 00000000000..47c685297d1 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_logic_and.txt @@ -0,0 +1,59 @@ +# Golden test output of SBEIfTest/IfWithLogicAnd +-- INPUT EXPRESSION: + + if (s1 && s2) + then "then" + else "else" + + +-- COMPILED EXPRESSION: +[0x0000-0x004e] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: jmpNothing(target: 0x002b); +0x000e: jmpTrue(target: 0x0022); +0x0013: pushConstVal(value: false); +0x001d: jmp(target: 0x002b); +0x0022: pushAccessVal(accessor: <accessor>); +0x002b: jmpNothing(target: 0x004e); +0x0030: jmpTrue(target: 0x0044); +0x0035: pushConstVal(value: "else"); +0x003f: jmp(target: 0x004e); +0x0044: pushConstVal(value: "then"); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: "then" + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_logic_not.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_logic_not.txt new file mode 100644 index 00000000000..0040cc99722 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_logic_not.txt @@ -0,0 +1,31 @@ +# Golden test output of SBEIfTest/IfWithLogicNot +-- INPUT EXPRESSION: + + if !(s1) + then "then" + else "else" + + +-- COMPILED EXPRESSION: +[0x0000-0x002e] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: logicNot(popParam: 1, offsetParam: 0); +0x000b: jmpNothing(target: 0x002e); +0x0010: jmpTrue(target: 0x0024); +0x0015: pushConstVal(value: "else"); +0x001f: jmp(target: 0x002e); +0x0024: pushConstVal(value: "then"); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false] +RESULT: "then" + +-- EXECUTE VARIATION: +SLOTS: [1: true] +RESULT: "else" + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_logic_or.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_logic_or.txt new file mode 100644 index 00000000000..e667819edca --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/if_with_logic_or.txt @@ -0,0 +1,59 @@ +# Golden test output of SBEIfTest/IfWithLogicOr +-- INPUT EXPRESSION: + + if (s1 || s2) + then "then" + else "else" + + +-- COMPILED EXPRESSION: +[0x0000-0x004e] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: jmpNothing(target: 0x002b); +0x000e: jmpTrue(target: 0x0021); +0x0013: pushAccessVal(accessor: <accessor>); +0x001c: jmp(target: 0x002b); +0x0021: pushConstVal(value: true); +0x002b: jmpNothing(target: 0x004e); +0x0030: jmpTrue(target: 0x0044); +0x0035: pushConstVal(value: "else"); +0x003f: jmp(target: 0x004e); +0x0044: pushConstVal(value: "then"); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: "then" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: "then" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: "then" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: "then" + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/nested_if_cond.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/nested_if_cond.txt new file mode 100644 index 00000000000..b956397c02b --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/nested_if_cond.txt @@ -0,0 +1,39 @@ +# Golden test output of SBEIfTest/NestedIfCond +-- INPUT EXPRESSION: + + if + if s1 + then false + else true + + then "then" + else "else" + + +-- COMPILED EXPRESSION: +[0x0000-0x004f] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: jmpNothing(target: 0x002c); +0x000e: jmpTrue(target: 0x0022); +0x0013: pushConstVal(value: true); +0x001d: jmp(target: 0x002c); +0x0022: pushConstVal(value: false); +0x002c: jmpNothing(target: 0x004f); +0x0031: jmpTrue(target: 0x0045); +0x0036: pushConstVal(value: "else"); +0x0040: jmp(target: 0x004f); +0x0045: pushConstVal(value: "then"); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false] +RESULT: "then" + +-- EXECUTE VARIATION: +SLOTS: [1: true] +RESULT: "else" + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/nested_if_else.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/nested_if_else.txt new file mode 100644 index 00000000000..36aef4a19cc --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/nested_if_else.txt @@ -0,0 +1,62 @@ +# Golden test output of SBEIfTest/NestedIfElse +-- INPUT EXPRESSION: + + if s2 + then "then2" + else + if s1 + then "then" + else "else" + + +-- COMPILED EXPRESSION: +[0x0000-0x004e] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: jmpNothing(target: 0x004e); +0x000e: jmpTrue(target: 0x0044); +0x0013: pushAccessVal(accessor: <accessor>); +0x001c: jmpNothing(target: 0x003f); +0x0021: jmpTrue(target: 0x0035); +0x0026: pushConstVal(value: "else"); +0x0030: jmp(target: 0x003f); +0x0035: pushConstVal(value: "then"); +0x003f: jmp(target: 0x004e); +0x0044: pushConstVal(value: "then2"); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: "then2" + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: "then2" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: "then" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: "then2" + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/nested_if_then.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/nested_if_then.txt new file mode 100644 index 00000000000..900f92ee9c8 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/nested_if_then.txt @@ -0,0 +1,63 @@ +# Golden test output of SBEIfTest/NestedIfThen +-- INPUT EXPRESSION: + + if s2 + then + if s1 + then "then" + else "else" + + else "else2" + + +-- COMPILED EXPRESSION: +[0x0000-0x004e] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: jmpNothing(target: 0x004e); +0x000e: jmpTrue(target: 0x0022); +0x0013: pushConstVal(value: "else2"); +0x001d: jmp(target: 0x004e); +0x0022: pushAccessVal(accessor: <accessor>); +0x002b: jmpNothing(target: 0x004e); +0x0030: jmpTrue(target: 0x0044); +0x0035: pushConstVal(value: "else"); +0x003f: jmp(target: 0x004e); +0x0044: pushConstVal(value: "then"); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: "else2" + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: "else2" + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: "else2" + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: "then" + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/simple_if.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/simple_if.txt new file mode 100644 index 00000000000..0ff0ab40bfa --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_if_test/simple_if.txt @@ -0,0 +1,30 @@ +# Golden test output of SBEIfTest/SimpleIf +-- INPUT EXPRESSION: + + if s1 + then "then" + else "else" + + +-- COMPILED EXPRESSION: +[0x0000-0x002c] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: jmpNothing(target: 0x002c); +0x000e: jmpTrue(target: 0x0022); +0x0013: pushConstVal(value: "else"); +0x001d: jmp(target: 0x002c); +0x0022: pushConstVal(value: "then"); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false] +RESULT: "else" + +-- EXECUTE VARIATION: +SLOTS: [1: true] +RESULT: "then" + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_lambda_test/traverse_f_op_eq.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_lambda_test/traverse_f_op_eq.txt new file mode 100644 index 00000000000..f00a7a5b0f1 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_lambda_test/traverse_f_op_eq.txt @@ -0,0 +1,19 @@ +# Golden test output of SBELambdaTest/TraverseF_OpEq +-- INPUT EXPRESSION: +traverseF(s1, lambda(l10.0) { (l10.0 == 3) }, Nothing) + +-- COMPILED EXPRESSION: +[0x0000-0x002b] +0x0000: jmp(target: 0x001c); +0x0005: allocStack(size:1); +0x000a: pushConstVal(value: 3); +0x0014: eq(popLhs: 0, offsetLhs: 0, popRhs: 1, offsetRhs: 0); +0x001b: ret(); +0x001c: pushAccessVal(accessor: <accessor>); +0x0025: traverseFImm(k: False, target: 0x0005); + + +-- EXECUTE VARIATION: +SLOTS: [1: [1, 2, 3, 4]] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_lambda_test/traverse_f_with_local_bind.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_lambda_test/traverse_f_with_local_bind.txt new file mode 100644 index 00000000000..50839afab8b --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_lambda_test/traverse_f_with_local_bind.txt @@ -0,0 +1,43 @@ +# Golden test output of SBELambdaTest/TraverseF_WithLocalBind +-- INPUT EXPRESSION: + + let [ + l20.0 = s1 + l20.1 = 10 + l20.2 = 20 + ] + in + if traverseF(l20.0, lambda(l10.0) { (l10.0 == 3) }, Nothing) + then l20.1 + else l20.2 + + +-- COMPILED EXPRESSION: +[0x0000-0x0063] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushConstVal(value: 10); +0x0013: pushConstVal(value: 20); +0x001d: jmp(target: 0x0039); +0x0022: allocStack(size:1); +0x0027: pushConstVal(value: 3); +0x0031: eq(popLhs: 0, offsetLhs: 0, popRhs: 1, offsetRhs: 0); +0x0038: ret(); +0x0039: pushLocalVal(arg: 2); +0x003e: traverseFImm(k: False, target: 0x0022); +0x0044: jmpNothing(target: 0x005d); +0x0049: jmpTrue(target: 0x0058); +0x004e: pushLocalVal(arg: 0); +0x0053: jmp(target: 0x005d); +0x0058: pushLocalVal(arg: 1); +0x005d: swap(); +0x005e: pop(); +0x005f: swap(); +0x0060: pop(); +0x0061: swap(); +0x0062: pop(); + + +-- EXECUTE VARIATION: +SLOTS: [1: [1, 2, 3, 4]] +RESULT: 10 + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_lambda_test/traverse_p_add_one_to_array.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_lambda_test/traverse_p_add_one_to_array.txt new file mode 100644 index 00000000000..91b718818f7 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_lambda_test/traverse_p_add_one_to_array.txt @@ -0,0 +1,19 @@ +# Golden test output of SBELambdaTest/TraverseP_AddOneToArray +-- INPUT EXPRESSION: +traverseP(s1, lambda(l10.0) { (l10.0 + 1) }, Nothing) + +-- COMPILED EXPRESSION: +[0x0000-0x002b] +0x0000: jmp(target: 0x001c); +0x0005: allocStack(size:1); +0x000a: pushConstVal(value: 1); +0x0014: add(popLhs: 0, offsetLhs: 0, popRhs: 1, offsetRhs: 0); +0x001b: ret(); +0x001c: pushAccessVal(accessor: <accessor>); +0x0025: traversePImm(k: Nothing, target: 0x0005); + + +-- EXECUTE VARIATION: +SLOTS: [1: [1, 2, 3]] +RESULT: [2, 3, 4] + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/nested_bind1.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/nested_bind1.txt new file mode 100644 index 00000000000..ede4ae8caf7 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/nested_bind1.txt @@ -0,0 +1,29 @@ +# Golden test output of SBELocalBindTest/NestedBind1 +-- INPUT EXPRESSION: + + let [ + l20.0 = 20 + ] + in ( + let [ + l10.0 = 10 + ] + in (l10.0 + l20.0) + + l20.0) + + +-- COMPILED EXPRESSION: +[0x0000-0x002a] +0x0000: pushConstVal(value: 20); +0x000a: pushConstVal(value: 10); +0x0014: add(popLhs: 0, offsetLhs: 0, popRhs: 0, offsetRhs: 1); +0x001f: swap(); +0x0020: pop(); +0x0021: add(popLhs: 1, offsetLhs: 0, popRhs: 0, offsetRhs: 1); +0x0028: swap(); +0x0029: pop(); + + +-- EXECUTE VARIATION: +RESULT: 50 + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/nested_bind2.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/nested_bind2.txt new file mode 100644 index 00000000000..4baac2d4b02 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/nested_bind2.txt @@ -0,0 +1,36 @@ +# Golden test output of SBELocalBindTest/NestedBind2 +-- INPUT EXPRESSION: + + let [ + l20.0 = + let [ + l10.0 = 10 + l10.1 = 20 + ] + in (l10.0 + l10.1) + + l20.1 = 30 + ] + in (l20.0 + l20.1) + + +-- COMPILED EXPRESSION: +[0x0000-0x003c] +0x0000: pushConstVal(value: 10); +0x000a: pushConstVal(value: 20); +0x0014: add(popLhs: 0, offsetLhs: 1, popRhs: 0, offsetRhs: 0); +0x001f: swap(); +0x0020: pop(); +0x0021: swap(); +0x0022: pop(); +0x0023: pushConstVal(value: 30); +0x002d: add(popLhs: 0, offsetLhs: 1, popRhs: 0, offsetRhs: 0); +0x0038: swap(); +0x0039: pop(); +0x003a: swap(); +0x003b: pop(); + + +-- EXECUTE VARIATION: +RESULT: 60 + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/one_variable.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/one_variable.txt new file mode 100644 index 00000000000..ed4205f6087 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/one_variable.txt @@ -0,0 +1,20 @@ +# Golden test output of SBELocalBindTest/OneVariable +-- INPUT EXPRESSION: + + let [ + l10.0 = 10 + ] + in (l10.0 + l10.0) + + +-- COMPILED EXPRESSION: +[0x0000-0x0017] +0x0000: pushConstVal(value: 10); +0x000a: add(popLhs: 0, offsetLhs: 0, popRhs: 0, offsetRhs: 0); +0x0015: swap(); +0x0016: pop(); + + +-- EXECUTE VARIATION: +RESULT: 20 + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/two_variables.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/two_variables.txt new file mode 100644 index 00000000000..3fc9c54a725 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_local_bind_test/two_variables.txt @@ -0,0 +1,24 @@ +# Golden test output of SBELocalBindTest/TwoVariables +-- INPUT EXPRESSION: + + let [ + l10.0 = 10 + l10.1 = 20 + ] + in (l10.0 + l10.1) + + +-- COMPILED EXPRESSION: +[0x0000-0x0023] +0x0000: pushConstVal(value: 10); +0x000a: pushConstVal(value: 20); +0x0014: add(popLhs: 0, offsetLhs: 1, popRhs: 0, offsetRhs: 0); +0x001f: swap(); +0x0020: pop(); +0x0021: swap(); +0x0022: pop(); + + +-- EXECUTE VARIATION: +RESULT: 30 + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_numeric_test/compile.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_numeric_test/compile.txt new file mode 100644 index 00000000000..5f5ebdeaba5 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_numeric_test/compile.txt @@ -0,0 +1,10 @@ +# Golden test output of SBENumericTest/Compile +-- INPUT EXPRESSION: +convert ( NumberDecimal(123), int64) + +-- COMPILED EXPRESSION: +[0x0000-0x000c] +0x0000: pushConstVal(value: NumberDecimal(123)); +0x000a: numConvert(tag: NumberInt64); + + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_numeric_test/compile_only.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_numeric_test/compile_only.txt new file mode 100644 index 00000000000..f9ca0d9cd42 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_numeric_test/compile_only.txt @@ -0,0 +1,10 @@ +# Golden test output of SBENumericTest/CompileOnly +-- INPUT EXPRESSION: +convert ( NumberDecimal(123), int64) + +-- COMPILED EXPRESSION: +[0x0000-0x000c] +0x0000: pushConstVal(value: NumberDecimal(123)); +0x000a: numConvert(tag: NumberInt64); + + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/add_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/add_mixed.txt new file mode 100644 index 00000000000..67c6216b021 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/add_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/AddMixed +-- INPUT EXPRESSION: +(s1 + s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: add(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 24 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(235.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: NumberDecimal(235.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(447.000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/add_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/add_numeric.txt new file mode 100644 index 00000000000..fa72ba31f3d --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/add_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/AddNumeric +-- INPUT EXPRESSION: +(s1 + s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: add(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 24 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: 35 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: 135ll + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: 135.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(235.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: 35 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: 46 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: 146ll + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: 146.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(246.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: 135ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: 146ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: 246ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: 246.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(346.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: 135.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: 146.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: 246.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: 247.000000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(347.000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: NumberDecimal(235.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: NumberDecimal(246.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: NumberDecimal(346.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: NumberDecimal(347.000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(447.000000000000) + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/cmp3w_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/cmp3w_mixed.txt new file mode 100644 index 00000000000..44cdcc099cc --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/cmp3w_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/Cmp3wMixed +-- INPUT EXPRESSION: +(s1 <=> s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: cmp3w(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: 0 + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/cmp3w_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/cmp3w_numeric.txt new file mode 100644 index 00000000000..dfa4a9a2b4f --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/cmp3w_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/Cmp3wNumeric +-- INPUT EXPRESSION: +(s1 <=> s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: cmp3w(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: 0 + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/cmp3w_string.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/cmp3w_string.txt new file mode 100644 index 00000000000..1fc401edbba --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/cmp3w_string.txt @@ -0,0 +1,312 @@ +# Golden test output of SBEPrimBinaryTest/Cmp3wString +-- INPUT EXPRESSION: +(s1 <=>[s3] s2) + +-- COMPILED EXPRESSION: +[0x0000-0x001f] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: pushAccessVal(accessor: <accessor>); +0x001b: collCmp3w(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0, popColl: 1, offsetColl: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: -1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 1 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: 0 + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/div_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/div_mixed.txt new file mode 100644 index 00000000000..37cbb8f09f5 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/div_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/DivMixed +-- INPUT EXPRESSION: +(s1 / s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: div(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 1.000000L + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(0.05369127516778523489932885906040268) + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: NumberDecimal(18.625000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(1) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/div_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/div_numeric.txt new file mode 100644 index 00000000000..a12b6838985 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/div_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/DivNumeric +-- INPUT EXPRESSION: +(s1 / s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: div(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 1.000000L + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: 0.521739L + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: 0.097561L + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: 0.097166L + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(0.05369127516778523489932885906040268) + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: 1.916667L + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: 1.000000L + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: 0.186992L + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: 0.186235L + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(0.1029082774049217002237136465324385) + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: 10.250000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: 5.347826L + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: 1.000000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: 0.995951L + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(0.5503355704697986577181208053691275) + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: 10.291667L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: 5.369565L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: 1.004065L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: 1.000000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(0.5525727069351230425055928411633110) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: NumberDecimal(18.625000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: NumberDecimal(9.717391304347826086956521739130435) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: NumberDecimal(1.817073170731707317073170731707317) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: NumberDecimal(1.809716599190283400809716599190283) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(1) + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/eq_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/eq_mixed.txt new file mode 100644 index 00000000000..e15b02760ae --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/eq_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/EqMixed +-- INPUT EXPRESSION: +(s1 == s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: eq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/eq_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/eq_numeric.txt new file mode 100644 index 00000000000..d4e31976424 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/eq_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/EqNumeric +-- INPUT EXPRESSION: +(s1 == s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: eq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/eq_string.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/eq_string.txt new file mode 100644 index 00000000000..8c8a84b474c --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/eq_string.txt @@ -0,0 +1,312 @@ +# Golden test output of SBEPrimBinaryTest/EqString +-- INPUT EXPRESSION: +(s1 ==[s3] s2) + +-- COMPILED EXPRESSION: +[0x0000-0x001f] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: pushAccessVal(accessor: <accessor>); +0x001b: collEq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0, popColl: 1, offsetColl: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/fill_empty.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/fill_empty.txt new file mode 100644 index 00000000000..48c7908d7dd --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/fill_empty.txt @@ -0,0 +1,77 @@ +# Golden test output of SBEPrimBinaryTest/FillEmpty +-- INPUT EXPRESSION: +(s1 ?: s2) + +-- COMPILED EXPRESSION: +[0x0000-0x001d] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: jmpNothing(target: 0x0013); +0x000e: jmp(target: 0x001d); +0x0013: pop(); +0x0014: pushAccessVal(accessor: <accessor>); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/fill_empty_with_constant.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/fill_empty_with_constant.txt new file mode 100644 index 00000000000..75356636101 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/fill_empty_with_constant.txt @@ -0,0 +1,108 @@ +# Golden test output of SBEPrimBinaryTest/FillEmptyWithConstant +== VARIATION rhs constant: Nothing +-- INPUT EXPRESSION: +(s1 ?: Nothing) + +-- COMPILED EXPRESSION: +[0x0000-0x001e] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: jmpNothing(target: 0x0013); +0x000e: jmp(target: 0x001e); +0x0013: pop(); +0x0014: pushConstVal(value: Nothing); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true] +RESULT: true + +== VARIATION rhs constant: null +-- INPUT EXPRESSION: +(s2 ?: null) + +-- COMPILED EXPRESSION: +[0x0000-0x000b] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: fillEmptyImm(k: Null); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: true + +== VARIATION rhs constant: true +-- INPUT EXPRESSION: +(s3 ?: true) + +-- COMPILED EXPRESSION: +[0x0000-0x000b] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: fillEmptyImm(k: True); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Nothing] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null, 3: null] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true, 3: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true, 3: true] +RESULT: true + +== VARIATION rhs constant: true +-- INPUT EXPRESSION: +(s4 ?: true) + +-- COMPILED EXPRESSION: +[0x0000-0x000b] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: fillEmptyImm(k: True); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Nothing, 4: Nothing] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null, 3: null, 4: null] +RESULT: null + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true, 3: true, 4: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true, 3: true, 4: true] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_eq_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_eq_mixed.txt new file mode 100644 index 00000000000..a5d9a6f475e --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_eq_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/GreaterEqMixed +-- INPUT EXPRESSION: +(s1 >= s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: greaterEq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_eq_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_eq_numeric.txt new file mode 100644 index 00000000000..c659666c713 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_eq_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/GreaterEqNumeric +-- INPUT EXPRESSION: +(s1 >= s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: greaterEq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_eq_string.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_eq_string.txt new file mode 100644 index 00000000000..cbe934c5069 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_eq_string.txt @@ -0,0 +1,312 @@ +# Golden test output of SBEPrimBinaryTest/GreaterEqString +-- INPUT EXPRESSION: +(s1 >=[s3] s2) + +-- COMPILED EXPRESSION: +[0x0000-0x001f] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: pushAccessVal(accessor: <accessor>); +0x001b: collGreaterEq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0, popColl: 1, offsetColl: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_mixed.txt new file mode 100644 index 00000000000..a45742ee565 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/GreaterMixed +-- INPUT EXPRESSION: +(s1 > s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: greater(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_numeric.txt new file mode 100644 index 00000000000..efee609318e --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/GreaterNumeric +-- INPUT EXPRESSION: +(s1 > s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: greater(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_string.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_string.txt new file mode 100644 index 00000000000..6b29bb1e035 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/greater_string.txt @@ -0,0 +1,312 @@ +# Golden test output of SBEPrimBinaryTest/GreaterString +-- INPUT EXPRESSION: +(s1 >[s3] s2) + +-- COMPILED EXPRESSION: +[0x0000-0x001f] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: pushAccessVal(accessor: <accessor>); +0x001b: collGreater(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0, popColl: 1, offsetColl: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_eq_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_eq_mixed.txt new file mode 100644 index 00000000000..e9884a5aee2 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_eq_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/LessEqMixed +-- INPUT EXPRESSION: +(s1 <= s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: lessEq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_eq_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_eq_numeric.txt new file mode 100644 index 00000000000..4d5a732442b --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_eq_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/LessEqNumeric +-- INPUT EXPRESSION: +(s1 <= s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: lessEq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_eq_string.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_eq_string.txt new file mode 100644 index 00000000000..5babaa80c6b --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_eq_string.txt @@ -0,0 +1,312 @@ +# Golden test output of SBEPrimBinaryTest/LessEqString +-- INPUT EXPRESSION: +(s1 <=[s3] s2) + +-- COMPILED EXPRESSION: +[0x0000-0x001f] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: pushAccessVal(accessor: <accessor>); +0x001b: collLessEq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0, popColl: 1, offsetColl: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_mixed.txt new file mode 100644 index 00000000000..3d617227507 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/LessMixed +-- INPUT EXPRESSION: +(s1 < s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: less(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_numeric.txt new file mode 100644 index 00000000000..f272ffe99e7 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/LessNumeric +-- INPUT EXPRESSION: +(s1 < s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: less(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_string.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_string.txt new file mode 100644 index 00000000000..a35a089c5df --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/less_string.txt @@ -0,0 +1,312 @@ +# Golden test output of SBEPrimBinaryTest/LessString +-- INPUT EXPRESSION: +(s1 <[s3] s2) + +-- COMPILED EXPRESSION: +[0x0000-0x001f] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: pushAccessVal(accessor: <accessor>); +0x001b: collLess(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0, popColl: 1, offsetColl: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/mul_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/mul_mixed.txt new file mode 100644 index 00000000000..745071fe431 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/mul_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/MulMixed +-- INPUT EXPRESSION: +(s1 * s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: mul(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 144 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(2682.000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: NumberDecimal(2682.000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(49952.250000000000000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/mul_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/mul_numeric.txt new file mode 100644 index 00000000000..3b2f59e35e1 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/mul_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/MulNumeric +-- INPUT EXPRESSION: +(s1 * s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: mul(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 144 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: 276 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: 1476ll + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: 1482.000000L + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(2682.000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: 276 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: 529 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: 2829ll + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: 2840.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(5140.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: 1476ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: 2829ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: 15129ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: 15190.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(27490.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: 1482.000000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: 2840.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: 15190.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: 15252.250000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(27602.250000000000000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: NumberDecimal(2682.000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: NumberDecimal(5140.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: NumberDecimal(27490.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: NumberDecimal(27602.250000000000000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(49952.250000000000000000000000) + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/neq_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/neq_mixed.txt new file mode 100644 index 00000000000..c1aa5c134f3 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/neq_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/NeqMixed +-- INPUT EXPRESSION: +(s1 != s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: neq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/neq_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/neq_numeric.txt new file mode 100644 index 00000000000..d2900d64212 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/neq_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/NeqNumeric +-- INPUT EXPRESSION: +(s1 != s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: neq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/neq_string.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/neq_string.txt new file mode 100644 index 00000000000..f25b52ea538 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/neq_string.txt @@ -0,0 +1,312 @@ +# Golden test output of SBEPrimBinaryTest/NeqString +-- INPUT EXPRESSION: +(s1 !=[s3] s2) + +-- COMPILED EXPRESSION: +[0x0000-0x001f] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: pushAccessVal(accessor: <accessor>); +0x001b: collNeq(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0, popColl: 1, offsetColl: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABC", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "abcdefghijkop", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: Nothing, 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abc", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABC", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "abcdefghijkop", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_always_equal", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: "ABCDEFGHIJKOP", 2: "ABCDEFGHIJKOP", 3: Collator({"locale" : "mock_to_lower_string", "caseLevel" : false, "caseFirst" : "off", "strength" : 3, "numericOrdering" : false, "alternate" : "non-ignorable", "maxVariable" : "punct", "normalization" : false, "backwards" : false, "version" : "mock_version"})] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/sub_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/sub_mixed.txt new file mode 100644 index 00000000000..799febcef6a --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/sub_mixed.txt @@ -0,0 +1,267 @@ +# Golden test output of SBEPrimBinaryTest/SubMixed +-- INPUT EXPRESSION: +(s1 - s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: sub(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(-211.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: NumberDecimal(211.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(0E-12) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc", 2: Timestamp(0, 1668792433)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433), 2: Timestamp(0, 1668792433)] +RESULT: Nothing + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/sub_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/sub_numeric.txt new file mode 100644 index 00000000000..e76850369b5 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_binary_test/sub_numeric.txt @@ -0,0 +1,155 @@ +# Golden test output of SBEPrimBinaryTest/SubNumeric +-- INPUT EXPRESSION: +(s1 - s2) + +-- COMPILED EXPRESSION: +[0x0000-0x0015] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: pushAccessVal(accessor: <accessor>); +0x0012: sub(popLhs: 1, offsetLhs: 0, popRhs: 1, offsetRhs: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 23] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123ll] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: 123.500000L] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing, 2: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 12] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 23] +RESULT: -11 + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123ll] +RESULT: -111ll + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: 123.500000L] +RESULT: -111.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 12, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(-211.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 12] +RESULT: 11 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 23] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123ll] +RESULT: -100ll + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: 123.500000L] +RESULT: -100.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 23, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(-200.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 12] +RESULT: 111ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 23] +RESULT: 100ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123ll] +RESULT: 0ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: 123.500000L] +RESULT: -0.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(-100.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 12] +RESULT: 111.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 23] +RESULT: 100.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123ll] +RESULT: 0.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: 123.500000L] +RESULT: 0.000000L + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L, 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(-100.000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 12] +RESULT: NumberDecimal(211.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 23] +RESULT: NumberDecimal(200.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123ll] +RESULT: NumberDecimal(100.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: 123.500000L] +RESULT: NumberDecimal(100.000000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000), 2: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(0E-12) + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/logic_not_bool.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/logic_not_bool.txt new file mode 100644 index 00000000000..b190a8bd42d --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/logic_not_bool.txt @@ -0,0 +1,22 @@ +# Golden test output of SBEPrimUnaryTest/LogicNotBool +-- INPUT EXPRESSION: +!(s1) + +-- COMPILED EXPRESSION: +[0x0000-0x000b] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: logicNot(popParam: 1, offsetParam: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true] +RESULT: false + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/logic_not_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/logic_not_mixed.txt new file mode 100644 index 00000000000..7df4fa4fc52 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/logic_not_mixed.txt @@ -0,0 +1,42 @@ +# Golden test output of SBEPrimUnaryTest/LogicNotMixed +-- INPUT EXPRESSION: +!(s1) + +-- COMPILED EXPRESSION: +[0x0000-0x000b] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: logicNot(popParam: 1, offsetParam: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: true] +RESULT: false + +-- EXECUTE VARIATION: +SLOTS: [1: 12] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000)] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433)] +RESULT: Nothing + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/negate_mixed.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/negate_mixed.txt new file mode 100644 index 00000000000..7005c2f8548 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/negate_mixed.txt @@ -0,0 +1,42 @@ +# Golden test output of SBEPrimUnaryTest/NegateMixed +-- INPUT EXPRESSION: +-(s1) + +-- COMPILED EXPRESSION: +[0x0000-0x000b] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: negate(popParam: 1, offsetParam: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: null] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: false] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 12] +RESULT: -12 + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(-223.500000000000) + +-- EXECUTE VARIATION: +SLOTS: [1: "abc"] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: Timestamp(0, 1668792433)] +RESULT: Nothing + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/negate_numeric.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/negate_numeric.txt new file mode 100644 index 00000000000..96e3bf54d76 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_prim_unary_test/negate_numeric.txt @@ -0,0 +1,38 @@ +# Golden test output of SBEPrimUnaryTest/NegateNumeric +-- INPUT EXPRESSION: +-(s1) + +-- COMPILED EXPRESSION: +[0x0000-0x000b] +0x0000: pushAccessVal(accessor: <accessor>); +0x0009: negate(popParam: 1, offsetParam: 0); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: 0] +RESULT: 0 + +-- EXECUTE VARIATION: +SLOTS: [1: 12] +RESULT: -12 + +-- EXECUTE VARIATION: +SLOTS: [1: 23] +RESULT: -23 + +-- EXECUTE VARIATION: +SLOTS: [1: 123ll] +RESULT: -123ll + +-- EXECUTE VARIATION: +SLOTS: [1: 123.500000L] +RESULT: -123.500000L + +-- EXECUTE VARIATION: +SLOTS: [1: NumberDecimal(223.500000000000)] +RESULT: NumberDecimal(-223.500000000000) + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_variable_test/local_variable.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_variable_test/local_variable.txt new file mode 100644 index 00000000000..72614a4406b --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_variable_test/local_variable.txt @@ -0,0 +1,22 @@ +# Golden test output of SBEVariableTest/LocalVariable +-- INPUT EXPRESSION: + + let [ + l10.0 = "abcdeghijklmnop" + ] + in newArray(l10.0, l10.0) + + +-- COMPILED EXPRESSION: +[0x0000-0x0019] +0x0000: pushConstVal(value: "abcdeghijklmnop"); +0x000a: pushLocalVal(arg: 0); +0x000f: pushLocalVal(arg: 1); +0x0014: functionSmall(f: newArray, arity: 2); +0x0017: swap(); +0x0018: pop(); + + +-- EXECUTE VARIATION: +RESULT: ["abcdeghijklmnop", "abcdeghijklmnop"] + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_variable_test/local_variable_move.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_variable_test/local_variable_move.txt new file mode 100644 index 00000000000..baf2548aca2 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_variable_test/local_variable_move.txt @@ -0,0 +1,22 @@ +# Golden test output of SBEVariableTest/LocalVariableMove +-- INPUT EXPRESSION: + + let [ + l10.0 = "abcdeghijklmnop" + ] + in newArray(move(l10.0), move(l10.0)) + + +-- COMPILED EXPRESSION: +[0x0000-0x0019] +0x0000: pushConstVal(value: "abcdeghijklmnop"); +0x000a: pushMoveLocalVal(arg: 0); +0x000f: pushMoveLocalVal(arg: 1); +0x0014: functionSmall(f: newArray, arity: 2); +0x0017: swap(); +0x0018: pop(); + + +-- EXECUTE VARIATION: +RESULT: ["abcdeghijklmnop"] + diff --git a/src/mongo/db/test_output/exec/sbe/s_b_e_variable_test/slot_variable.txt b/src/mongo/db/test_output/exec/sbe/s_b_e_variable_test/slot_variable.txt new file mode 100644 index 00000000000..1f1204f22c9 --- /dev/null +++ b/src/mongo/db/test_output/exec/sbe/s_b_e_variable_test/slot_variable.txt @@ -0,0 +1,21 @@ +# Golden test output of SBEVariableTest/SlotVariable +-- INPUT EXPRESSION: +s1 + +-- COMPILED EXPRESSION: +[0x0000-0x0009] +0x0000: pushAccessVal(accessor: <accessor>); + + +-- EXECUTE VARIATION: +SLOTS: [1: Nothing] +RESULT: Nothing + +-- EXECUTE VARIATION: +SLOTS: [1: true] +RESULT: true + +-- EXECUTE VARIATION: +SLOTS: [1: 123] +RESULT: 123 + |