class ListFacade:
    """ A facade for a pyarrow ListScalar """
    def __init__(self, lst: pyarrow.lib.ListScalar):
        self.lst = lst

    def __getitem__(self, index: int):
        val_type = self.lst.type.value_type
        return convert_value(self.lst[index],val_type)

    def __len__(self):
        return len(self.lst)


class StructFacade:
    """ A facade for a pyarrow StructScalar """
    def __init__(self, struct: pyarrow.lib.StructScalar):
        self.struct = struct

    def __getattr__(self, key: str):
        field = self.struct.type[key]
        return convert_value(self.struct[key],field.type)


class RecordFacade:
    """ A facade for a single row in a pyarrow RecordBatch """

    def __init__(self, batch: pyarrow.lib.RecordBatch, row_num: int):
        self.batch = batch
        self.row_num = row_num

    def __getattr__(self, key: str):
        field = self.batch.schema.field(key)
        return convert_value(self.batch.column(key)[self.row_num],field.type)

class BatchReaderFacade[T]:
    """Wrapper for batch reader that yields rows as facades"""
    def __init__(self, reader:pyarrow.lib.RecordBatchReader):
        self.reader = reader

    def rows(self) -> typing.Iterable[T]:
        """ Yields each row in the batch as a RecordFacade that provides attributes for Protocol T"""
        for batch in self.reader:
            for i in range(batch.num_rows):
                yield RecordFacade(batch, i)

## Converter
```python
def convert_value(value,schema:pyarrow.lib.DataType):
    """ Convert a pyarrow value to a Python value or a facade object """
    if pyarrow.types.is_struct(schema):
        return StructFacade(value)
    if pyarrow.types.is_primitive(schema):
        return value.as_py()
    if pyarrow.types.is_list(schema):
        return ListFacade(value)
    raise ValueError(f"Unsupported type: {schema}")

class DatabaseFunctionParam(Protocol):
    name: str
    dtype: str

class DatabaseFunction(Protocol):
    name: str
    kind: str
    return_type: str
    params: list[DatabaseFunctionParam]
    database: str

class DatabaseSchema(Protocol):
    id: int
    name: str
    functions: list[DatabaseFunction]