We only care about the the commit section.
The rest is simply passed to its parent.
965028
@Override
  public <T> Cursor<T> selectCursor(String statement) {
    return session.selectCursor(statement);
  }
121389
private void takeSnapshotIfCommitIndexAdvanced() {
        long commitIndex = state.commitIndex();
        if ((commitIndex - state.log().snapshotIndex()) < commitIndexAdvanceCountToSnapshot) {
            return;
        }

        if (isTerminatedOrSteppedDown()) {
            // If the status is UPDATING_MEMBER_LIST or TERMINATING, it means the status is normally ACTIVE
            // and there is an appended but not committed RaftGroupCmd.
            // If the status is TERMINATED or STEPPED_DOWN, then there will not be any new appends.
            return;
        }

        RaftLog log = state.log();
        Object snapshot = raftIntegration.takeSnapshot(commitIndex);
        if (snapshot instanceof Throwable) {
            Throwable t = (Throwable) snapshot;
            logger.severe("Could not take snapshot at commit index: " + commitIndex, t);
            return;
        }

        int snapshotTerm = log.getLogEntry(commitIndex).term();
        RaftGroupMembers members = state.committedGroupMembers();
        SnapshotEntry snapshotEntry = new SnapshotEntry(snapshotTerm, commitIndex, snapshot, members.index(), members.members());

        long minMatchIndex = 0L;
        LeaderState leaderState = state.leaderState();
        if (leaderState != null) {
            long[] indices = leaderState.matchIndices();
            // Last slot is reserved for leader index,
            // and always zero. That's why we are skipping it.
            Arrays.sort(indices, 0, indices.length - 1);
            minMatchIndex = indices[0];
        }

        long truncateLogsUpToIndex = max(commitIndex - maxNumberOfLogsToKeepAfterSnapshot, minMatchIndex);
        int truncated = log.setSnapshot(snapshotEntry, truncateLogsUpToIndex);

        if (logger.isFineEnabled()) {
            logger.fine(snapshotEntry + " is taken, " + truncated + " entries are truncated.");
        }
    }
856360
def delete_commit(self, commit):
        
        req = proto.DeleteCommitRequest(commit=commit_from(commit))
        self.stub.DeleteCommit(req, metadata=self.metadata)
159512
public void sync(boolean syncAllSegments)
    {
        CommitLogSegment current = allocator.allocatingFrom();
        for (CommitLogSegment segment : allocator.getActiveSegments())
        {
            if (!syncAllSegments && segment.id > current.id)
                return;
            segment.sync();
        }
    }
179035
def commit(self):
        
        if hasattr(self.local, 'tx') and self.local.tx:
            tx = self.local.tx.pop()
            tx.commit()
            self._flush_tables()
237282
public function commit(): void
    {
        if (null !== $this->changes) {
            $this->commitInternal($this->changes);

            $this->changes = null;
        }
    }
835750
@Override
  public void commit()
      throws IOException {

    if (!this.actualProcessedCopyableFile.isPresent()) {
      return;
    }

    CopyableFile copyableFile = this.actualProcessedCopyableFile.get();
    Path stagingFilePath = getStagingFilePath(copyableFile);
    Path outputFilePath = getSplitOutputFilePath(copyableFile, this.outputDir,
        copyableFile.getDatasetAndPartition(this.copyableDatasetMetadata), this.state);

    log.info(String.format("Committing data from %s to %s", stagingFilePath, outputFilePath));
    try {
      setFilePermissions(copyableFile);

      Iterator<OwnerAndPermission> ancestorOwnerAndPermissionIt =
          copyableFile.getAncestorsOwnerAndPermission() == null ? Iterators.<OwnerAndPermission>emptyIterator()
              : copyableFile.getAncestorsOwnerAndPermission().iterator();

      ensureDirectoryExists(this.fs, outputFilePath.getParent(), ancestorOwnerAndPermissionIt);

      this.fileContext.rename(stagingFilePath, outputFilePath, renameOptions);
    } catch (IOException ioe) {
      log.error("Could not commit file %s.", outputFilePath);
      // persist file
      this.recoveryHelper.persistFile(this.state, copyableFile, stagingFilePath);
      throw ioe;
    } finally {
      try {
        this.fs.delete(this.stagingDir, true);
      } catch (IOException ioe) {
        log.warn("Failed to delete staging path at " + this.stagingDir);
      }
    }
  }
669851
public final void commit() {
        ensureNotYetCreated();
        ensureHasChanges();
        alreadyCreated = true;
        area.replaceMulti(Collections.unmodifiableList(list));
    }
185492
def commit(self):
        
        self.query.globl['branch'] = self._obranch
        self.query.globl['turn'] = self._oturn
        self.query.globl['tick'] = self._otick
        set_branch = self.query.set_branch
        for branch, (parent, turn_start, tick_start, turn_end, tick_end) in self._branches.items():
            set_branch(branch, parent, turn_start, tick_start, turn_end, tick_end)
        turn_end = self._turn_end
        set_turn = self.query.set_turn
        for (branch, turn), plan_end_tick in self._turn_end_plan.items():
            set_turn(branch, turn, turn_end[branch], plan_end_tick)
        if self._plans_uncommitted:
            self.query.plans_insert_many(self._plans_uncommitted)
        if self._plan_ticks_uncommitted:
            self.query.plan_ticks_insert_many(self._plan_ticks_uncommitted)
        self.query.commit()
        self._plans_uncommitted = []
        self._plan_ticks_uncommitted = []
201761
private void dispatchCommitActions(List<CommitTaskAction> commitActions)
      throws IOException {
    if (!commitActions.isEmpty()) {
      TaskAttemptID[] wasCommitting;
      try {
        wasCommitting = commitPermissionClient
            .getAndSetCommitting(commitActions);
      } catch (IOException e) {
        LOG.error("Commit permission client is faulty - killing this JT");
        try {
          close(false);
        } catch (InterruptedException e1) {
          throw new IOException(e1);
        }
        throw e;
      }
      int i = 0;
      for (CommitTaskAction action : commitActions) {
        TaskAttemptID oldCommitting = wasCommitting[i];
        if (oldCommitting != null) {
          // Fail old committing task attempt
          failTask(oldCommitting, "Unknown committing attempt", false);
        }
        // Commit new task
        TaskAttemptID newToCommit = action.getTaskID();
        if (!newToCommit.equals(oldCommitting)) {
          String trackerName = taskLookupTable.getAssignedTracker(newToCommit);
          taskLauncher.commitTask(trackerName,
              resourceTracker.getTrackerAddr(trackerName), action);
        } else {
          LOG.warn("Repeated try to commit same attempt id. Ignoring");
        }
        // iterator next
        ++i;
      }
    }
  }
259160
public void commit() {
    if (directory == null)
      return;

    try {
      if (reader != null)
        reader.close();

      // it turns out that IndexWriter.optimize actually slows
      // searches down, because it invalidates the cache. therefore
      // not calling it any more.
      // http://www.searchworkings.org/blog/-/blogs/uwe-says%3A-is-your-reader-atomic
      // iwriter.optimize();

      iwriter.commit();
      openSearchers();
    } catch (IOException e) {
      throw new DukeException(e);
    }
  }
554631
function() {
			this._commitUndo();
			var change, result = false;
			this._ignoreUndo = true;
			do {
				if (this.index <= 0) {
					break;
				}
				change = this.stack[--this.index];
			} while (!(result = change.undo(this.view, true)));
			this._ignoreUndo = false;
			return result;
		}
1266155
@Override
    public void actionCommit() {

        List<Throwable> errors = new ArrayList<Throwable>();

        try {

            m_searchManager.removeSearchIndexSource(m_indexsource);
            clearDialogObject();
            writeConfiguration();
            // if we go back to /searchindex/singleindex (overview) the deleted searchindex is not
            // there any more in the CmsSearchManager and CmsOverviewSearchIndex.getUserObject will
            // find null -> defineWidgets will provide null as bean...
            setParamCloseLink(CmsToolManager.linkForToolPath(getJsp(), "/searchindex/indexsources"));

        } catch (Throwable t) {
            errors.add(t);
        }
        // set the list of errors to display when saving failed
        setCommitErrors(errors);
    }
520154
def _commit(self):
        
        if self._id is None:
            mode = _datastore_pb2.CommitRequest.NON_TRANSACTIONAL
        else:
            mode = _datastore_pb2.CommitRequest.TRANSACTIONAL

        commit_response_pb = self._client._datastore_api.commit(
            self.project, mode, self._mutations, transaction=self._id
        )
        _, updated_keys = _parse_commit_response(commit_response_pb)
        # If the back-end returns without error, we are guaranteed that
        # ``commit`` will return keys that match (length and
        # order) directly ``_partial_key_entities``.
        for new_key_pb, entity in zip(updated_keys, self._partial_key_entities):
            new_id = new_key_pb.path[-1].id
            entity.key = entity.key.completed_key(new_id)
320509
def commit(self):
        
        logger.debug('Committing job {0}'.format(self.name))
        self.backend.commit_job(self._serialize())
        self.parent.commit()
1212689
public void commit() {
        if (isBuffering()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Committing buffered value '" + getValue() + "' to wrapped value model '" + wrappedModel
                        + "'");
            }
            wrappedModel.setValueSilently(getValueToCommit(), wrappedModelChangeHandler);
            setValue(wrappedModel.getValue()); // check if the wrapped model changed the committed value
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("No buffered edit to commit; nothing to do...");
            }
        }
    }
303257
def commit(self):
        
        while len(self.__buffer) > 0:
            self.__run(self.__buffer.pop(0))