class_docstr: Represent the PostgreSQL HSTORE type.
  
  The :class:`.HSTORE` type stores dictionaries containing strings, e.g.::
  
      data_table = Table('data_table', metadata,
          Column('id', Integer, primary_key=True),
          Column('data', HSTORE)
      )
  
      with engine.connect() as conn:
          conn.execute(
              data_table.insert(),
              data = {"key1": "value1", "key2": "value2"}
          )
  
  :class:`.HSTORE` provides for a wide range of operations, including:
  
  * Index operations::
  
      data_table.c.data['some key'] == 'some value'
  
  * Containment operations::
  
      data_table.c.data.has_key('some key')
  
      data_table.c.data.has_all(['one', 'two', 'three'])
  
  * Concatenation::
  
      data_table.c.data + {"k1": "v1"}
  
  For a full list of special methods see
  :class:`.HSTORE.comparator_factory`.
  
  .. container:: topic
  
      **Detecting Changes in HSTORE columns when using the ORM**
  
      For usage with the SQLAlchemy ORM, it may be desirable to combine the
      usage of :class:`.HSTORE` with :class:`.MutableDict` dictionary now
      part of the :mod:`sqlalchemy.ext.mutable` extension. This extension
      will allow "in-place" changes to the dictionary, e.g. addition of new
      keys or replacement/removal of existing keys to/from the current
      dictionary, to produce events which will be detected by the unit of
      work::
  
          from sqlalchemy.ext.mutable import MutableDict
  
          class MyClass(Base):
              __tablename__ = 'data_table'
  
              id = Column(Integer, primary_key=True)
              data = Column(MutableDict.as_mutable(HSTORE))
  
          my_object = session.query(MyClass).one()
  
          # in-place mutation, requires Mutable extension
          # in order for the ORM to detect
          my_object.data['some_key'] = 'some value'
  
          session.commit()
  
      When the :mod:`sqlalchemy.ext.mutable` extension is not used, the ORM
      will not be alerted to any changes to the contents of an existing
      dictionary, unless that dictionary value is re-assigned to the
      HSTORE-attribute itself, thus generating a change event.
  
  .. seealso::
  
      :class:`.hstore` - render the PostgreSQL ``hstore()`` function.
docstr: Construct a new :class:`.HSTORE`.
  
  :param text_type: the type that should be used for indexed values.
   Defaults to :class:`_types.Text`.
docstr_tok: ["Construct","a","new",":","class",":","`",".HSTORE","`",".",":","param","text_type",":","the","type","that","should","be","used","for","indexed","values",".","Defaults","to",":","class",":","`","_types.Text","`","."]
code: def __init__(self, text_type=None):
      """Construct a new :class:`.HSTORE`.
  
      :param text_type: the type that should be used for indexed values.
       Defaults to :class:`_types.Text`.
  
      """
      if text_type is not None:
          self.text_type = text_type
  
imports: import re
  from .array import ARRAY
  from .operators import CONTAINED_BY
  from .operators import CONTAINS
  from .operators import GETITEM
  from .operators import HAS_ALL
  from .operators import HAS_ANY
  from .operators import HAS_KEY
  from ...None import types
  from ...sql import functions
label_desc: Use image node_id 1 to create a new HSTORE object from inherited base classes: sqltypes, sqltypes, sqltypes with example: obj = HSTORE(text_type)