docs: def _init_compiled(cls, dialect, connection, dbapi_connection,
                         compiled, parameters):
          """Initialize execution context for a Compiled construct."""
  
          self = cls.__new__(cls)
          self.root_connection = connection
          self._dbapi_connection = dbapi_connection
          self.dialect = connection.dialect
  
          self.compiled = compiled
  
          # this should be caught in the engine before
          # we get here
          assert compiled.can_execute
  
          self.execution_options = compiled.execution_options.union(
              connection._execution_options)
  
          self.result_column_struct = (
              compiled._result_columns, compiled._ordered_columns,
              compiled._textual_ordered_columns)
  
          self.unicode_statement = util.text_type(compiled)
          if not dialect.supports_unicode_statements:
              self.statement = self.unicode_statement.encode(
                  self.dialect.encoding)
          else:
              self.statement = self.unicode_statement
  
          self.isinsert = compiled.isinsert
          self.isupdate = compiled.isupdate
          self.isdelete = compiled.isdelete
          self.is_text = compiled.isplaintext
  
          if not parameters:
              self.compiled_parameters = [compiled.construct_params()]
          else:
              self.compiled_parameters = \
                  [compiled.construct_params(m, _group_number=grp) for
                   grp, m in enumerate(parameters)]
  
              self.executemany = len(parameters) > 1
  
          self.cursor = self.create_cursor()
  
          if self.isinsert or self.isupdate or self.isdelete:
              self.is_crud = True
              self._is_explicit_returning = bool(compiled.statement._returning)
              self._is_implicit_returning = bool(
                  compiled.returning and not compiled.statement._returning)
  
          if self.compiled.insert_prefetch or self.compiled.update_prefetch:
              if self.executemany:
                  self._process_executemany_defaults()
              else:
                  self._process_executesingle_defaults()
  
          processors = compiled._bind_processors
  
          # Convert the dictionary of bind parameter values
          # into a dict or list to be sent to the DBAPI's
          # execute() or executemany() method.
          parameters = []
          if dialect.positional:
              for compiled_params in self.compiled_parameters:
                  param = []
                  for key in self.compiled.positiontup:
                      if key in processors:
                          param.append(processors[key](compiled_params[key]))
                      else:
                          param.append(compiled_params[key])
                  parameters.append(dialect.execute_sequence_format(param))
          else:
              encode = not dialect.supports_unicode_statements
              for compiled_params in self.compiled_parameters:
  
                  if encode:
                      param = dict(
                          (
                              dialect._encoder(key)[0],
                              processors[key](compiled_params[key])
                              if key in processors
                              else compiled_params[key]
                          )
                          for key in compiled_params
                      )
                  else:
                      param = dict(
                          (
                              key,
                              processors[key](compiled_params[key])
                              if key in processors
                              else compiled_params[key]
                          )
                          for key in compiled_params
                      )
  
                  parameters.append(param)
          self.parameters = dialect.execute_sequence_format(parameters)
  
          self.statement = compiled
          return self