**Describe the unexpected behaviour**
Clickhouse does not support parquet with 'large_utf8' columns (only 'utf8'). From my understanding, the only difference is offsets are u64 in 'large_utf8' instead of u32

**How to reproduce**

```
import pyarrow
import pyarrow.parquet
import subprocess


for schema in (None,pyarrow.schema({"a": pyarrow.large_utf8()})):
    a = pyarrow.table({"a": ["00000"]}, schema=schema)
    pyarrow.parquet.write_table(a, "test.parquet")
    subprocess.run(
        """cat test.parquet | clickhouse local \
            --input-format "Parquet" \
            --structure "a String" \
            --query "select * from table"\
        """,
        shell=True,
        check=True,
    )

```
gives
```
00000
Code: 50. DB::Exception: Unsupported Parquet type 'large_utf8' of an input column 'a'.: While executing ParquetBlockInputFormat: While executing File. (UNKNOWN_TYPE)
```



nested_arrow_columns[i].emplace_back(struct_chunk.field(i));
            }
            Columns tuple_elements;
            DataTypes tuple_types;
            std::vector<String> tuple_names;
            for (int i = 0; i != arrow_struct_type->num_fields(); ++i)
            {
                auto nested_arrow_column = std::make_shared<arrow::ChunkedArray>(nested_arrow_columns[i]);
                auto element = readColumnFromArrowColumn(nested_arrow_column, arrow_struct_type->field(i)->name(), format_name, false, dictionary_values, read_ints_as_dates, allow_null_type, skip_columns_with_unsupported_types, skipped);
                if (skipped)
                    return {};
                tuple_elements.emplace_back(std::move(element.column));
                tuple_types.emplace_back(std::move(element.type));
                tuple_names.emplace_back(std::move(element.name));
            }
            auto tuple_column = ColumnTuple::create(std::move(tuple_elements));
            auto tuple_type = std::make_shared<DataTypeTuple>(std::move(tuple_types), std::move(tuple_names));
            return {std::move(tuple_column), std::move(tuple_type), column_name};
        }
        case arrow::Type::DICTIONARY:
        {
            auto & dict_values = dictionary_values[column_name];
            
            if (!dict_values)
            {
                arrow::ArrayVector dict_array;
                for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->num_chunks()); chunk_i < num_chunks; ++chunk_i)
                {
                    arrow::DictionaryArray & dict_chunk = dynamic_cast<arrow::DictionaryArray &>(*(arrow_column->chunk(chunk_i)));
                    dict_array.emplace_back(dict_chunk.dictionary());