Method executeImpl

src/Functions/map.cpp:978–1030

    inline String getColumnStringValue(const ColumnWithTypeAndName & argument) const { return argument.column->getDataAt(0).toString(); }

    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
    {
        String db_name = getColumnStringValue(arguments[0]);
        String table_name = getColumnStringValue(arguments[1]);
        String column_name = getColumnStringValue(arguments[2]);
        if (db_name.empty() || table_name.empty() || column_name.empty())
            throw Exception("Bad arguments: database/table/column should not be empty", ErrorCodes::BAD_ARGUMENTS);

        String pattern;
        if (arguments.size() >= 4)
        {
            pattern = getColumnStringValue(arguments[3]);
        }

        /// Check byte map type
        auto table_id = context->resolveStorageID({db_name, table_name});
        auto table = DatabaseCatalog::instance().getTable(table_id, context);
        auto metadata_snapshot = table->getInMemoryMetadataPtr();
        if (!metadata_snapshot || !metadata_snapshot->columns.hasPhysical(column_name))
            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Table {}.{} doesn't contain column {}", db_name, table_name, column_name);
        auto type = metadata_snapshot->columns.getPhysical(column_name).type;
        if (!type->isMap() || type->isKVMap())
            throw Exception(
                ErrorCodes::BAD_ARGUMENTS, "Function getMapKeys must apply to ByteMap but given {}", type->isKVMap() ? "KV map" : type->getName());

        /**
            SELECT groupUniqArrayArray(ks) AS keys FROM (
                SELECT arrayMap(t -> t.2, arrayFilter(t -> t.1 = 'some_map', _map_column_keys)) AS ks
                FROM some_db.some_table WHERE match(_partition_id, '.*2020.*10.*10.*')
            ) SETTINGS early_limit_for_map_virtual_columns = 1, max_threads = 1
        */
        String inner_query = "SELECT arrayMap(t -> t.2, arrayFilter(t -> t.1 = '" + column_name + "', _map_column_keys)) AS ks" //
            + " FROM `" + db_name + "`.`" + table_name + "`" //
            + (pattern.empty() ? "" : " WHERE match(_partition_id, '" + pattern + "')");
        String query = "SELECT groupUniqArrayArray(ks) AS keys FROM ( " + inner_query
            + " ) SETTINGS early_limit_for_map_virtual_columns = 1, max_threads = 1";

        auto query_context = createContextForSubQuery(context);
        auto res = executeSubQueryWithOneRow(query, query_context, true);
        if (res)
        {
            // TODO(shiyuze): maybe add a new function to get result in different rows, just like arrayJoin(getMapKeys(xxx))

            /// Total map key number in result may exceed max_array_size_as_field (for example, 
            /// each pratition or bucket has different key sets), so we need to avoid calling 
            /// ColumnArray::[] or ColumnArray::get() to get array as a Field here.
            return ColumnConst::create(res.getByName("keys").column, input_rows_count)->convertToFullColumnIfConst();
        }
        else
        {
            return result_type->createColumnConst(input_rows_count, Array{})->convertToFullColumnIfConst();
        }
    }

    /// override executeImplDryRun to prevent calling getMapKeys multi times under
    /// same txn id, which may cause worker create table multi times