Method generateNextCreateTable

src/Client/BuzzHouse/Generator/SQLTable.cpp:2315–2574

}

void StatementGenerator::generateNextCreateTable(RandomGenerator & rg, const bool in_parallel, CreateTable * ct)
{
    SQLTable next;
    bool has_ttl = false;
    bool added_pkey = false;
    TableEngine * te = ct->mutable_engine();
    const bool alltables = rg.nextMediumNumber() < 26;
    const bool prev_enforce_final = this->enforce_final;
    const bool prev_allow_not_deterministic = this->allow_not_deterministic;

    SQLBase::setDeterministic(fc, rg, next);
    this->allow_not_deterministic = !next.is_deterministic;
    this->enforce_final = next.is_deterministic;
    next.is_temp = fc.allow_memory_tables && rg.nextMediumNumber() < 11;
    ct->set_is_temp(next.is_temp);

    const auto tableLikeLambda = [&next, &alltables](const SQLTable & t)
    { return t.isAttached() && (!t.is_temp || alltables) && (t.is_deterministic || !next.is_deterministic); };
    const auto replaceTableLambda
        = [&next](const SQLTable & t) { return t.isAttached() && !t.hasDatabasePeer() && (t.is_deterministic || !next.is_deterministic); };
    const bool replace = collectionCount<SQLTable>(replaceTableLambda) > 3 && rg.nextMediumNumber() < 16;
    if (replace)
    {
        const SQLTable & t = rg.pickRandomly(filterCollection<SQLTable>(replaceTableLambda));

        next.db = t.db;
        next.name = t.getBaseName();
        next.counter = t.counter;
    }
    else
    {
        if ((!next.is_temp || alltables) && collectionHas<std::shared_ptr<SQLDatabase>>(attached_databases) && rg.nextSmallNumber() < 9)
        {
            next.db = rg.pickRandomly(filterCollection<std::shared_ptr<SQLDatabase>>(attached_databases));
        }
        next.counter = this->table_counter++;
        next.name = rg.nextIdentifier("t", next.counter, fc.allow_nasty_identifiers);
    }
    ct->set_create_opt(
        replace ? (rg.nextBool() ? CreateReplaceOption::CreateOrReplace : CreateReplaceOption::Replace) : CreateReplaceOption::Create);
    next.setName(ct->mutable_est(), false);
    if (!collectionHas<SQLTable>(tableLikeLambda) || rg.nextSmallNumber() < 9)
    {
        /// Create table with definition
        TableDef * colsdef = ct->mutable_table_def();

        getNextTableEngine(rg, !in_parallel, next);
        te->set_engine(next.teng);
        if (!in_parallel)
        {
            getNextPeerTableDatabase(rg, next);
        }
        added_pkey
            |= (!next.isMergeTreeFamily() && !next.isRocksEngine() && !next.isKeeperMapEngine() && !next.isRedisEngine()
                && !next.isMaterializedPostgreSQLEngine());
        has_ttl = !next.is_deterministic && (next.isMergeTreeFamily() || rg.nextLargeNumber() < 8) && rg.nextBool();

        const bool add_version_to_replacing