docs: def _cursor(self):
          '''
          Override _cursor to plug in our connection pool code.  We'll return a wrapped Connection
          which can handle returning itself to the pool when its .close() method is called.
          '''
          from django.db.backends.postgresql.version import get_version
  
          new_connection = False
          set_tz = False
          settings_dict = self.settings_dict
  
          if self.connection is None or connection_pools[self.alias]['settings'] != settings_dict:
              new_connection = True
              set_tz = settings_dict.get('TIME_ZONE')
  
              # Is this the initial use of the global connection_pools dictionary for 
              # this python interpreter? Build a ThreadedConnectionPool instance and 
              # add it to the dictionary if so.
              if self.alias not in connection_pools or connection_pools[self.alias]['settings'] != settings_dict:
                  if settings_dict['NAME'] == '':
                      from django.core.exceptions import ImproperlyConfigured
                      raise ImproperlyConfigured("You need to specify NAME in your Django settings file.")
                  conn_params = {
                      'database': settings_dict['NAME'],
                  }
                  conn_params.update(settings_dict['OPTIONS'])
                  for extra in ['autocommit'] + pool_config_defaults.keys():
                      if extra in conn_params:
                          del conn_params[extra]
                  if settings_dict['USER']:
                      conn_params['user'] = settings_dict['USER']
                  if settings_dict['PASSWORD']:
                      conn_params['password'] = settings_dict['PASSWORD']
                  if settings_dict['HOST']:
                      conn_params['host'] = settings_dict['HOST']
                  if settings_dict['PORT']:
                      conn_params['port'] = settings_dict['PORT']
  
                  self.create_connection_pool(conn_params)
  
              self.connection = PooledConnection(connection_pools[self.alias]['pool'], 
                                                 test_query=self._test_on_borrow_query)
              self.connection.set_client_encoding('UTF8')
              self.connection.set_isolation_level(self.isolation_level)
              # We'll continue to emulate the old signal frequency in case any code depends upon it
              connection_created.send(sender=self.__class__, connection=self)
          cursor = self.connection.cursor()
          cursor.tzinfo_factory = None
          if new_connection:
              if set_tz:
                  cursor.execute("SET TIME ZONE %s", [settings_dict['TIME_ZONE']])
              if not hasattr(self, '_version'):
                  self.__class__._version = get_version(cursor)
              if self._version[0:2] < (8, 0):
                  # No savepoint support for earlier version of PostgreSQL.
                  self.features.uses_savepoints = False
              if self.features.uses_autocommit:
                  if self._version[0:2] < (8, 2):
                      # FIXME: Needs extra code to do reliable model insert
                      # handling, so we forbid it for now.
                      from django.core.exceptions import ImproperlyConfigured
                      raise ImproperlyConfigured("You cannot use autocommit=True with PostgreSQL prior to 8.2 at the moment.")
                  else:
                      # FIXME: Eventually we're enable this by default for
                      # versions that support it, but, right now, that's hard to
                      # do without breaking other things (#10509).
                      self.features.can_return_id_from_insert = True
          return CursorWrapper(cursor)