Method NewSimpleBatch

src/sdk/sql_request_row_test.cc:183–226

class SQLRequestRowBatchTest : public ::testing::Test {
 public:
    SQLRequestRowBatch* NewSimpleBatch(const std::vector<size_t>& common_column_indices) {
        ::hybridse::vm::Schema schema;
        InitSimpleSchema(&schema);

        ::hybridse::sdk::SchemaImpl* schema_impl =
            new ::hybridse::sdk::SchemaImpl(schema);
        std::shared_ptr<::hybridse::sdk::Schema> schema_shared(schema_impl);

        auto r1 = std::make_shared<SQLRequestRow>(schema_shared, std::set<std::string>());
        r1->Init(5);
        r1->AppendInt32(32);
        r1->AppendString("hello");
        r1->AppendInt64(64);
        r1->Build();

        auto r2 = std::make_shared<SQLRequestRow>(schema_shared, std::set<std::string>());
        r2->Init(5);
        r2->AppendInt32(32);
        r2->AppendString("world");
        r2->AppendInt64(64);
        r2->Build();

        common_schema.Clear();
        non_common_schema.Clear();
        for (int i = 0; i < schema.size(); ++i) {
            if (std::find(common_column_indices.begin(), common_column_indices.end(), i)
                    != common_column_indices.end() &&
                common_column_indices.size() != static_cast<size_t>(schema.size())) {
                *common_schema.Add() = schema.Get(i);
            } else {
                *non_common_schema.Add() = schema.Get(i);
            }
        }

        auto indice_set = std::make_shared<ColumnIndicesSet>(schema_shared);
        for (size_t idx : common_column_indices) {
            indice_set->AddCommonColumnIdx(idx);
        }

        auto batch = new SQLRequestRowBatch(schema_shared, indice_set);
        batch->AddRow(r1);
        batch->AddRow(r2);
        return batch;
    }

    ::hybridse::vm::Schema common_schema;
    ::hybridse::vm::Schema non_common_schema;