Esempio n. 1
0
TEST_F(TableTupleTest, VolatilePoolBackedTuple) {
    UniqueEngine engine = UniqueEngineBuilder().build();
    Pool pool;

    // A schema with
    //    - one fixed size column
    //    - one inlined variable-length column
    //    - one non-inlined variable-length column
    ScopedTupleSchema schema{Tools::buildSchema(VALUE_TYPE_BIGINT,
                                                std::make_pair(VALUE_TYPE_VARCHAR, 12),
                                                std::make_pair(VALUE_TYPE_VARCHAR, 256))};
    PoolBackedTupleStorage poolBackedTuple;
    poolBackedTuple.init(schema.get(), &pool);
    poolBackedTuple.allocateActiveTuple();
    TableTuple &tuple = poolBackedTuple;

    Tools::setTupleValues(&tuple, int64_t(0), "foo", "foo bar");

    // Pool-backed tuples are used as "scratch areas" so their data is
    // frequently mutated.  NValues that reference them could have
    // their data changed.
    //
    // Non-inlined data is not volatile though.
    ASSERT_TRUE(tuple.inlinedDataIsVolatile());
    ASSERT_FALSE(tuple.nonInlinedDataIsVolatile());

    NValue nv = tuple.getNValue(0);
    ASSERT_FALSE(nv.getVolatile());

    nv = tuple.getNValue(1);
    ASSERT_TRUE(nv.getVolatile());

    // After the NValue is made to be non-inlined (copied to temp string pool)
    // it is no longer volatile
    nv.allocateObjectFromPool();
    ASSERT_FALSE(nv.getVolatile());

    nv = tuple.getNValue(2);
    ASSERT_FALSE(nv.getVolatile());
}
Esempio n. 2
0
TEST_F(LargeTempTableTest, MultiBlock) {
    UniqueEngine engine = UniqueEngineBuilder().build();
    LargeTempTableBlockCache* lttBlockCache = ExecutorContext::getExecutorContext()->lttBlockCache();
    ASSERT_EQ(0, lttBlockCache->totalBlockCount());

    const int INLINE_LEN = 15;
    const int NONINLINE_LEN = 50000;

    std::vector<std::string> names{
        "pk",
        "val0",
        "val1",
        "val2",
        "dec0",
        "dec1",
        "dec2",
        "text0",
        "text1",
        "text2",
        "bigtext"
    };

    TupleSchema* schema = Tools::buildSchema(
        //                                       status byte: 1
        VALUE_TYPE_BIGINT,                                //  8
        VALUE_TYPE_DOUBLE,                                //  8
        VALUE_TYPE_DOUBLE,                                //  8
        VALUE_TYPE_DOUBLE,                                //  8
        VALUE_TYPE_DECIMAL,                               // 16
        VALUE_TYPE_DECIMAL,                               // 16
        VALUE_TYPE_DECIMAL,                               // 16
        std::make_pair(VALUE_TYPE_VARCHAR, INLINE_LEN),   // 61
        std::make_pair(VALUE_TYPE_VARCHAR, INLINE_LEN),   // 61
        std::make_pair(VALUE_TYPE_VARCHAR, INLINE_LEN),   // 61
        std::make_pair(VALUE_TYPE_VARCHAR, NONINLINE_LEN)); //  8 (pointer to non-inlined)
    // --> Tuple length is 272 bytes (not counting non-inlined data)

    auto ltt = makeUniqueTable(TableFactory::buildLargeTempTable(
        "ltmp",
        schema,
        names));

    TableTuple tuple = ltt->tempTuple();
    ASSERT_EQ(0, lttBlockCache->numPinnedEntries());

    const int NUM_TUPLES = 500;
    // Attempt to insert enough rows so that we have more than one
    // block in this table.
    //   inline data:
    //                 136000    (500 * 272)
    //
    // Four kinds of non-inlined strings:
    //   NULL               0    (125 * 0)
    //   empty string    1500    (125 * 12, StringRef and length prefix)
    //   half string  3126500    (125 * (25000 + 12))
    //   whole string 6251500    (125 * (50000 + 12))
    //
    // Total -->      9515500
    //
    // LTT blocks are 8MB so this data should use two blocks.
    for (int64_t i = 0; i < NUM_TUPLES; ++i) {
        Tools::setTupleValues(&tuple,
                              i,
                              0.5 * i,
                              0.5 * i + 1,
                              0.5 * i + 2,
                              Tools::toDec(0.5 * i),
                              Tools::toDec(0.5 * i + 1),
                              Tools::toDec(0.5 * i + 2),
                              getStringValue(INLINE_LEN, i),
                              getStringValue(INLINE_LEN, i + 1),
                              getStringValue(INLINE_LEN, i + 2),
                              getStringValue(NONINLINE_LEN, i));
        ASSERT_TRUE(tuple.inlinedDataIsVolatile());
        ASSERT_FALSE(tuple.nonInlinedDataIsVolatile());
        ltt->insertTuple(tuple);
    }

    // The block we were inserting into will be pinned
    ASSERT_EQ(1, lttBlockCache->numPinnedEntries());

    // Indicate that we are done inserting...
    ltt->finishInserts();

    // Block is now unpinned
    ASSERT_EQ(0, lttBlockCache->numPinnedEntries());

    ASSERT_EQ(2, ltt->allocatedBlockCount());

    {
        TableIterator iter = ltt->iterator();
        TableTuple iterTuple(ltt->schema());
        int64_t i = 0;
        while (iter.next(iterTuple)) {
            boost::optional<std::string> inlineStr0 = getStringValue(INLINE_LEN, i);
            boost::optional<std::string> inlineStr1 = getStringValue(INLINE_LEN, i + 1);
            boost::optional<std::string> inlineStr2 = getStringValue(INLINE_LEN, i + 2);
            boost::optional<std::string> nonInlineStr = getStringValue(NONINLINE_LEN, i);

            assertTupleValuesEqual(&iterTuple,
                                   i,
                                   0.5 * i,
                                   0.5 * i + 1,
                                   0.5 * i + 2,
                                   Tools::toDec(0.5 * i),
                                   Tools::toDec(0.5 * i + 1),
                                   Tools::toDec(0.5 * i + 2),
                                   inlineStr0,
                                   inlineStr1,
                                   inlineStr2,
                                   nonInlineStr);
            // Check volatility of inserted values
            NValue nv = iterTuple.getNValue(0);
            ASSERT_FALSE(nv.getVolatile()); // bigint

            nv = iterTuple.getNValue(7); // inlined varchar
            ASSERT_TRUE(nv.getVolatile());

            // It can be made non-volatile by allocating in a pool:
            nv.allocateObjectFromPool();
            ASSERT_FALSE(nv.getVolatile());
            ASSERT_EQ(0, Tools::nvalueCompare(inlineStr0, nv));

            nv = iterTuple.getNValue(10); // non-inlined varchar
            ASSERT_TRUE(nv.getVolatile());

            // It can be made non-volatile by allocating in a pool:
            nv.allocateObjectFromPool();
            ASSERT_FALSE(nv.getVolatile());
            ASSERT_EQ(0, Tools::nvalueCompare(nonInlineStr, nv));

            ++i;
        }

        ASSERT_EQ(500, i);
    }

    ltt->deleteAllTempTuples();

    ASSERT_EQ(0, lttBlockCache->totalBlockCount());
    ASSERT_EQ(0, lttBlockCache->allocatedMemory());
}