class_docstr: PostgreSQL ARRAY type.
  
  The :class:`_postgresql.ARRAY` type is constructed in the same way
  as the core :class:`_types.ARRAY` type; a member type is required, and a
  number of dimensions is recommended if the type is to be used for more
  than one dimension::
  
      from sqlalchemy.dialects import postgresql
  
      mytable = Table("mytable", metadata,
              Column("data", postgresql.ARRAY(Integer, dimensions=2))
          )
  
  The :class:`_postgresql.ARRAY` type provides all operations defined on the
  core :class:`_types.ARRAY` type, including support for "dimensions",
  indexed access, and simple matching such as
  :meth:`.types.ARRAY.Comparator.any` and
  :meth:`.types.ARRAY.Comparator.all`.  :class:`_postgresql.ARRAY`
  class also
  provides PostgreSQL-specific methods for containment operations, including
  :meth:`.postgresql.ARRAY.Comparator.contains`
  :meth:`.postgresql.ARRAY.Comparator.contained_by`, and
  :meth:`.postgresql.ARRAY.Comparator.overlap`, e.g.::
  
      mytable.c.data.contains([1, 2])
  
  The :class:`_postgresql.ARRAY` type may not be supported on all
  PostgreSQL DBAPIs; it is currently known to work on psycopg2 only.
  
  Additionally, the :class:`_postgresql.ARRAY`
  type does not work directly in
  conjunction with the :class:`.ENUM` type.  For a workaround, see the
  special type at :ref:`postgresql_array_of_enum`.
  
  .. container:: topic
  
      **Detecting Changes in ARRAY columns when using the ORM**
  
      The :class:`_postgresql.ARRAY` type, when used with the SQLAlchemy ORM,
      does not detect in-place mutations to the array. In order to detect
      these, the :mod:`sqlalchemy.ext.mutable` extension must be used, using
      the :class:`.MutableList` class::
  
          from sqlalchemy.dialects.postgresql import ARRAY
          from sqlalchemy.ext.mutable import MutableList
  
          class SomeOrmClass(Base):
              # ...
  
              data = Column(MutableList.as_mutable(ARRAY(Integer)))
  
      This extension will allow "in-place" changes such to the array
      such as ``.append()`` to produce events which will be detected by the
      unit of work.  Note that changes to elements **inside** the array,
      including subarrays that are mutated in place, are **not** detected.
  
      Alternatively, assigning a new array value to an ORM element that
      replaces the old one will always trigger a change event.
  
  .. seealso::
  
      :class:`_types.ARRAY` - base array type
  
      :class:`_postgresql.array` - produces a literal array value.
code: def literal_processor(self, dialect):
      item_proc = self.item_type.dialect_impl(
          dialect
      ).literal_processor(dialect)
      if item_proc is None:
          return None
  
      def to_str(elements):
          return f"ARRAY[{', '.join(elements)}]"
  
      def process(value):
          inner = self._apply_item_processor(
              value, item_proc, self.dimensions, to_str
          )
          return inner
  
      return process
  
imports: from __future__ import annotations
  import re
  from typing import Any
  from typing import Optional
  from typing import TypeVar
  from .operators import CONTAINED_BY
  from .operators import CONTAINS
  from .operators import OVERLAP
  from ...None import types
  from ...None import util
  from ...sql import expression
  from ...sql import operators
  from ...sql._typing import _TypeEngineArgument
label_desc: Use image node_id 6 for calling the ARRAY obj's underlying member method code with example usage: obj.literal_processor(dialect) and returns: process, None, str, str, str, inner