Method orderAndSave

src/jrd/sort.cpp:1946–2004

void Sort::orderAndSave(thread_db* tdbb)
{
/**************************************
 *
 * The memory full of record pointers has been sorted, but more
 * records remain, so the run will have to be written to scratch file.
 * If target run can be allocated in contiguous chunk of memory then
 * just memcpy records into it. Else call more expensive order() to
 * physically rearrange records in sort space and write its run into
 * scratch file as one big chunk
 *
 **************************************/
	EngineCheckout cout(tdbb, FB_FUNCTION);

	run_control* run = m_runs;
	run->run_records = 0;

	sort_record** ptr = m_first_pointer + 1; // 1st ptr is low key
	// m_next_pointer points to the end of pointer memory or the beginning of records
	while (ptr < m_next_pointer)
	{
		// If the next pointer is null, it's record has been eliminated as a
		// duplicate.  This is the only easy case.
		if (!(*ptr++))
			continue;

		run->run_records++;
	}

	const ULONG key_length = (m_longs - SIZEOF_SR_BCKPTR_IN_LONGS) * sizeof(ULONG);
	run->run_size = run->run_records * key_length;
	run->run_seek = m_space->allocateSpace(run->run_size);

	UCHAR* mem = m_space->inMemory(run->run_seek, run->run_size);

	if (mem)
	{
		ptr = m_first_pointer + 1;
		while (ptr < m_next_pointer)
		{
			SR* record = (SR*) (*ptr++);

			if (!record)
				continue;

			// make record point back to the starting of SR struct.
			// as all m_*_pointer point to the key_id locations!
			record = (SR*) (((SORTP*)record) - SIZEOF_SR_BCKPTR_IN_LONGS);

			memcpy(mem, record->sr_sort_record.sort_record_key, key_length);
			mem += key_length;
		}
	}
	else
	{
		order();
		writeBlock(m_space, run->run_seek, (UCHAR*) m_last_record, run->run_size);
	}