transformers

package
v6.13.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 5, 2024 License: BSD-2-Clause Imports: 24 Imported by: 0

README

Logic for transforming input records into output records as requested by the user (sort, filter, etc.).:

  • The IRecordTransformer abstract record-transformer interface datatype, as well as the ChainTransformer Go-channel chaining mechanism for piping one transformer into the next.
  • The transformer lookup table, used for Miller command-line parsing, verb construction, and online help.
  • All the concrete record-transformers such as cat, tac, sort, put, and so on.

Documentation

Overview

Package transformer contains logic for transforming input records into output records as requested by the user (sort, filter, etc.).

Index

Constants

View Source 
const DEFAULT_STRING_ALPHA = "0.5"

For EWMA

Variables

View Source 
var AltkvSetup = TransformerSetup{
	Verb:         verbNameAltkv,
	UsageFunc:    transformerAltkvUsage,
	ParseCLIFunc: transformerAltkvParseCLI,
	IgnoresInput: false,
}
View Source 
var BarSetup = TransformerSetup{
	Verb:         verbNameBar,
	UsageFunc:    transformerBarUsage,
	ParseCLIFunc: transformerBarParseCLI,
	IgnoresInput: false,
}
View Source 
var BootstrapSetup = TransformerSetup{
	Verb:         verbNameBootstrap,
	UsageFunc:    transformerBootstrapUsage,
	ParseCLIFunc: transformerBootstrapParseCLI,
	IgnoresInput: false,
}
View Source 
var CaseSetup = TransformerSetup{
	Verb:         verbNameCase,
	UsageFunc:    transformerCaseUsage,
	ParseCLIFunc: transformerCaseParseCLI,
	IgnoresInput: false,
}
View Source 
var CatSetup = TransformerSetup{
	Verb:         verbNameCat,
	UsageFunc:    transformerCatUsage,
	ParseCLIFunc: transformerCatParseCLI,
	IgnoresInput: false,
}
View Source 
var CheckSetup = TransformerSetup{
	Verb:         verbNameCheck,
	UsageFunc:    transformerCheckUsage,
	ParseCLIFunc: transformerCheckParseCLI,
	IgnoresInput: false,
}
View Source 
var CleanWhitespaceSetup = TransformerSetup{
	Verb:         verbNameCleanWhitespace,
	UsageFunc:    transformerCleanWhitespaceUsage,
	ParseCLIFunc: transformerCleanWhitespaceParseCLI,
	IgnoresInput: false,
}
View Source 
var CountDistinctSetup = TransformerSetup{
	Verb:         verbNameCountDistinct,
	UsageFunc:    transformerCountDistinctUsage,
	ParseCLIFunc: transformerCountDistinctParseCLI,
	IgnoresInput: false,
}
View Source 
var CountSetup = TransformerSetup{
	Verb:         verbNameCount,
	UsageFunc:    transformerCountUsage,
	ParseCLIFunc: transformerCountParseCLI,
	IgnoresInput: false,
}
View Source 
var CountSimilarSetup = TransformerSetup{
	Verb:         verbNameCountSimilar,
	UsageFunc:    transformerCountSimilarUsage,
	ParseCLIFunc: transformerCountSimilarParseCLI,
	IgnoresInput: false,
}
View Source 
var CutSetup = TransformerSetup{
	Verb:         verbNameCut,
	UsageFunc:    transformerCutUsage,
	ParseCLIFunc: transformerCutParseCLI,
	IgnoresInput: false,
}
View Source 
var DecimateSetup = TransformerSetup{
	Verb:         verbNameDecimate,
	UsageFunc:    transformerDecimateUsage,
	ParseCLIFunc: transformerDecimateParseCLI,
	IgnoresInput: false,
}
View Source 
var FillDownSetup = TransformerSetup{
	Verb:         verbNameFillDown,
	UsageFunc:    transformerFillDownUsage,
	ParseCLIFunc: transformerFillDownParseCLI,
	IgnoresInput: false,
}
View Source 
var FillEmptySetup = TransformerSetup{
	Verb:         verbNameFillEmpty,
	UsageFunc:    transformerFillEmptyUsage,
	ParseCLIFunc: transformerFillEmptyParseCLI,
	IgnoresInput: false,
}
View Source 
var FilterSetup = TransformerSetup{
	Verb:         verbNameFilter,
	UsageFunc:    transformerFilterUsage,
	ParseCLIFunc: transformerPutOrFilterParseCLI,
	IgnoresInput: false,
}
View Source 
var FlattenSetup = TransformerSetup{
	Verb:         verbNameFlatten,
	UsageFunc:    transformerFlattenUsage,
	ParseCLIFunc: transformerFlattenParseCLI,
	IgnoresInput: false,
}
View Source 
var FormatValuesSetup = TransformerSetup{
	Verb:         verbNameFormatValues,
	UsageFunc:    transformerFormatValuesUsage,
	ParseCLIFunc: transformerFormatValuesParseCLI,
	IgnoresInput: false,
}
View Source 
var FractionSetup = TransformerSetup{
	Verb:         verbNameFraction,
	UsageFunc:    transformerFractionUsage,
	ParseCLIFunc: transformerFractionParseCLI,
	IgnoresInput: false,
}
View Source 
var GapSetup = TransformerSetup{
	Verb:         verbNameGap,
	UsageFunc:    transformerGapUsage,
	ParseCLIFunc: transformerGapParseCLI,
	IgnoresInput: false,
}
View Source 
var GrepSetup = TransformerSetup{
	Verb:         verbNameGrep,
	UsageFunc:    transformerGrepUsage,
	ParseCLIFunc: transformerGrepParseCLI,
	IgnoresInput: false,
}
View Source 
var GroupBySetup = TransformerSetup{
	Verb:         verbNameGroupBy,
	UsageFunc:    transformerGroupByUsage,
	ParseCLIFunc: transformerGroupByParseCLI,
	IgnoresInput: false,
}
View Source 
var GroupLikeSetup = TransformerSetup{
	Verb:         verbNameGroupLike,
	UsageFunc:    transformerGroupLikeUsage,
	ParseCLIFunc: transformerGroupLikeParseCLI,
	IgnoresInput: false,
}
View Source 
var GsubSetup = TransformerSetup{
	Verb:         verbNameGsub,
	UsageFunc:    transformerGsubUsage,
	ParseCLIFunc: transformerGsubParseCLI,
	IgnoresInput: false,
}
View Source 
var HavingFieldsSetup = TransformerSetup{
	Verb:         verbNameHavingFields,
	UsageFunc:    transformerHavingFieldsUsage,
	ParseCLIFunc: transformerHavingFieldsParseCLI,

	IgnoresInput: false,
}
View Source 
var HeadSetup = TransformerSetup{
	Verb:         verbNameHead,
	UsageFunc:    transformerHeadUsage,
	ParseCLIFunc: transformerHeadParseCLI,
	IgnoresInput: false,
}
View Source 
var HistogramSetup = TransformerSetup{
	Verb:         verbNameHistogram,
	UsageFunc:    transformerHistogramUsage,
	ParseCLIFunc: transformerHistogramParseCLI,
	IgnoresInput: false,
}
View Source 
var JSONParseSetup = TransformerSetup{
	Verb:         verbNameJSONParse,
	UsageFunc:    transformerJSONParseUsage,
	ParseCLIFunc: transformerJSONParseParseCLI,
	IgnoresInput: false,
}
View Source 
var JSONStringifySetup = TransformerSetup{
	Verb:         verbNameJSONStringify,
	UsageFunc:    transformerJSONStringifyUsage,
	ParseCLIFunc: transformerJSONStringifyParseCLI,
	IgnoresInput: false,
}
View Source 
var JoinSetup = TransformerSetup{
	Verb:         verbNameJoin,
	UsageFunc:    transformerJoinUsage,
	ParseCLIFunc: transformerJoinParseCLI,
	IgnoresInput: false,
}
View Source 
var LabelSetup = TransformerSetup{
	Verb:         verbNameLabel,
	UsageFunc:    transformerLabelUsage,
	ParseCLIFunc: transformerLabelParseCLI,
	IgnoresInput: false,
}
View Source 
var Latin1ToUTF8Setup = TransformerSetup{
	Verb:         verbNameLatin1ToUTF8,
	UsageFunc:    transformerLatin1ToUTF8Usage,
	ParseCLIFunc: transformerLatin1ToUTF8ParseCLI,
	IgnoresInput: false,
}
View Source 
var LeastFrequentSetup = TransformerSetup{
	Verb:         verbNameLeastFrequent,
	UsageFunc:    transformerLeastFrequentUsage,
	ParseCLIFunc: transformerLeastFrequentParseCLI,
	IgnoresInput: false,
}
View Source 
var MergeFieldsSetup = TransformerSetup{
	Verb:         verbNameMergeFields,
	UsageFunc:    transformerMergeFieldsUsage,
	ParseCLIFunc: transformerMergeFieldsParseCLI,
	IgnoresInput: false,
}
View Source 
var MostFrequentSetup = TransformerSetup{
	Verb:         verbNameMostFrequent,
	UsageFunc:    transformerMostFrequentUsage,
	ParseCLIFunc: transformerMostFrequentParseCLI,
	IgnoresInput: false,
}
View Source 
var NestSetup = TransformerSetup{
	Verb:         verbNameNest,
	UsageFunc:    transformerNestUsage,
	ParseCLIFunc: transformerNestParseCLI,
	IgnoresInput: false,
}
View Source 
var NothingSetup = TransformerSetup{
	Verb:         verbNameNothing,
	ParseCLIFunc: transformerNothingParseCLI,
	UsageFunc:    transformerNothingUsage,
	IgnoresInput: false,
}
View Source 
var PutSetup = TransformerSetup{
	Verb:         verbNamePut,
	UsageFunc:    transformerPutUsage,
	ParseCLIFunc: transformerPutOrFilterParseCLI,
	IgnoresInput: false,
}
View Source 
var RegularizeSetup = TransformerSetup{
	Verb:         verbNameRegularize,
	UsageFunc:    transformerRegularizeUsage,
	ParseCLIFunc: transformerRegularizeParseCLI,
	IgnoresInput: false,
}
View Source 
var RemoveEmptyColumnsSetup = TransformerSetup{
	Verb:         verbNameRemoveEmptyColumns,
	UsageFunc:    transformerRemoveEmptyColumnsUsage,
	ParseCLIFunc: transformerRemoveEmptyColumnsParseCLI,
	IgnoresInput: false,
}
View Source 
var RenameSetup = TransformerSetup{
	Verb:         verbNameRename,
	UsageFunc:    transformerRenameUsage,
	ParseCLIFunc: transformerRenameParseCLI,
	IgnoresInput: false,
}
View Source 
var ReorderSetup = TransformerSetup{
	Verb:         verbNameReorder,
	UsageFunc:    transformerReorderUsage,
	ParseCLIFunc: transformerReorderParseCLI,
	IgnoresInput: false,
}
View Source 
var RepeatSetup = TransformerSetup{
	Verb:         verbNameRepeat,
	UsageFunc:    transformerRepeatUsage,
	ParseCLIFunc: transformerRepeatParseCLI,

	IgnoresInput: false,
}
View Source 
var ReshapeSetup = TransformerSetup{
	Verb:         verbNameReshape,
	UsageFunc:    transformerReshapeUsage,
	ParseCLIFunc: transformerReshapeParseCLI,
	IgnoresInput: false,
}
View Source 
var STEPPER_LOOKUP_TABLE = []tStepperLookup{
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
}
View Source 
var SampleSetup = TransformerSetup{
	Verb:         verbNameSample,
	UsageFunc:    transformerSampleUsage,
	ParseCLIFunc: transformerSampleParseCLI,
	IgnoresInput: false,
}
View Source 
var Sec2GMTDateSetup = TransformerSetup{
	Verb:         verbNameSec2GMTDate,
	UsageFunc:    transformerSec2GMTDateUsage,
	ParseCLIFunc: transformerSec2GMTDateParseCLI,
	IgnoresInput: false,
}
View Source 
var Sec2GMTSetup = TransformerSetup{
	Verb:         verbNameSec2GMT,
	UsageFunc:    transformerSec2GMTUsage,
	ParseCLIFunc: transformerSec2GMTParseCLI,
	IgnoresInput: false,
}
View Source 
var SeqgenSetup = TransformerSetup{
	Verb:         verbNameSeqgen,
	UsageFunc:    transformerSeqgenUsage,
	ParseCLIFunc: transformerSeqgenParseCLI,
	IgnoresInput: true,
}
View Source 
var ShuffleSetup = TransformerSetup{
	Verb:         verbNameShuffle,
	UsageFunc:    transformerShuffleUsage,
	ParseCLIFunc: transformerShuffleParseCLI,
	IgnoresInput: false,
}
View Source 
var SkipTrivialRecordsSetup = TransformerSetup{
	Verb:         verbNameSkipTrivialRecords,
	UsageFunc:    transformerSkipTrivialRecordsUsage,
	ParseCLIFunc: transformerSkipTrivialRecordsParseCLI,
	IgnoresInput: false,
}
View Source 
var SortSetup = TransformerSetup{
	Verb:         verbNameSort,
	UsageFunc:    transformerSortUsage,
	ParseCLIFunc: transformerSortParseCLI,
	IgnoresInput: false,
}
View Source 
var SortWithinRecordsSetup = TransformerSetup{
	Verb:         verbNameSortWithinRecords,
	UsageFunc:    transformerSortWithinRecordsUsage,
	ParseCLIFunc: transformerSortWithinRecordsParseCLI,
	IgnoresInput: false,
}
View Source 
var SparsifySetup = TransformerSetup{
	Verb:         verbNameSparsify,
	UsageFunc:    transformerSparsifyUsage,
	ParseCLIFunc: transformerSparsifyParseCLI,
	IgnoresInput: false,
}
View Source 
var SplitSetup = TransformerSetup{
	Verb:         verbNameSplit,
	UsageFunc:    transformerSplitUsage,
	ParseCLIFunc: transformerSplitParseCLI,
	IgnoresInput: false,
}
View Source 
var SsubSetup = TransformerSetup{
	Verb:         verbNameSsub,
	UsageFunc:    transformerSsubUsage,
	ParseCLIFunc: transformerSsubParseCLI,
	IgnoresInput: false,
}
View Source 
var Stats1Setup = TransformerSetup{
	Verb:         verbNameStats1,
	UsageFunc:    transformerStats1Usage,
	ParseCLIFunc: transformerStats1ParseCLI,
	IgnoresInput: false,
}
View Source 
var Stats2Setup = TransformerSetup{
	Verb:         verbNameStats2,
	UsageFunc:    transformerStats2Usage,
	ParseCLIFunc: transformerStats2ParseCLI,
	IgnoresInput: false,
}
View Source 
var StepSetup = TransformerSetup{
	Verb:         verbNameStep,
	UsageFunc:    transformerStepUsage,
	ParseCLIFunc: transformerStepParseCLI,
	IgnoresInput: false,
}
View Source 
var SubSetup = TransformerSetup{
	Verb:         verbNameSub,
	UsageFunc:    transformerSubUsage,
	ParseCLIFunc: transformerSubParseCLI,
	IgnoresInput: false,
}
View Source 
var SummarySetup = TransformerSetup{
	Verb:         verbNameSummary,
	UsageFunc:    transformerSummaryUsage,
	ParseCLIFunc: transformerSummaryParseCLI,
	IgnoresInput: false,
}
View Source 
var TRANSFORMER_LOOKUP_TABLE = []TransformerSetup{
	AltkvSetup,
	BarSetup,
	BootstrapSetup,
	CaseSetup,
	CatSetup,
	CheckSetup,
	CleanWhitespaceSetup,
	CountDistinctSetup,
	CountSetup,
	CountSimilarSetup,
	CutSetup,
	DecimateSetup,
	FillDownSetup,
	FillEmptySetup,
	FilterSetup,
	FlattenSetup,
	FormatValuesSetup,
	FractionSetup,
	GapSetup,
	GrepSetup,
	GroupBySetup,
	GroupLikeSetup,
	GsubSetup,
	HavingFieldsSetup,
	HeadSetup,
	HistogramSetup,
	JSONParseSetup,
	JSONStringifySetup,
	JoinSetup,
	LabelSetup,
	Latin1ToUTF8Setup,
	LeastFrequentSetup,
	MergeFieldsSetup,
	MostFrequentSetup,
	NestSetup,
	NothingSetup,
	PutSetup,
	RegularizeSetup,
	RemoveEmptyColumnsSetup,
	RenameSetup,
	ReorderSetup,
	RepeatSetup,
	ReshapeSetup,
	SampleSetup,
	Sec2GMTDateSetup,
	Sec2GMTSetup,
	SeqgenSetup,
	ShuffleSetup,
	SkipTrivialRecordsSetup,
	SortSetup,
	SortWithinRecordsSetup,
	SparsifySetup,
	SplitSetup,
	SsubSetup,
	Stats1Setup,
	Stats2Setup,
	StepSetup,
	SubSetup,
	SummarySetup,
	TacSetup,
	TailSetup,
	TeeSetup,
	TemplateSetup,
	TopSetup,
	UTF8ToLatin1Setup,
	UnflattenSetup,
	UniqSetup,
	UnspaceSetup,
	UnsparsifySetup,
}

----------------------------------------------------------------

View Source 
var TacSetup = TransformerSetup{
	Verb:         verbNameTac,
	UsageFunc:    transformerTacUsage,
	ParseCLIFunc: transformerTacParseCLI,
	IgnoresInput: false,
}
View Source 
var TailSetup = TransformerSetup{
	Verb:         verbNameTail,
	UsageFunc:    transformerTailUsage,
	ParseCLIFunc: transformerTailParseCLI,
	IgnoresInput: false,
}
View Source 
var TeeSetup = TransformerSetup{
	Verb:         verbNameTee,
	UsageFunc:    transformerTeeUsage,
	ParseCLIFunc: transformerTeeParseCLI,
	IgnoresInput: false,
}
View Source 
var TemplateSetup = TransformerSetup{
	Verb:         verbNameTemplate,
	UsageFunc:    transformerTemplateUsage,
	ParseCLIFunc: transformerTemplateParseCLI,
	IgnoresInput: false,
}
View Source 
var TopSetup = TransformerSetup{
	Verb:         verbNameTop,
	UsageFunc:    transformerTopUsage,
	ParseCLIFunc: transformerTopParseCLI,
	IgnoresInput: false,
}
View Source 
var UTF8ToLatin1Setup = TransformerSetup{
	Verb:         verbNameUTF8ToLatin1,
	UsageFunc:    transformerUTF8ToLatin1Usage,
	ParseCLIFunc: transformerUTF8ToLatin1ParseCLI,
	IgnoresInput: false,
}
View Source 
var UnflattenSetup = TransformerSetup{
	Verb:         verbNameUnflatten,
	UsageFunc:    transformerUnflattenUsage,
	ParseCLIFunc: transformerUnflattenParseCLI,
	IgnoresInput: false,
}
View Source 
var UniqSetup = TransformerSetup{
	Verb:         verbNameUniq,
	UsageFunc:    transformerUniqUsage,
	ParseCLIFunc: transformerUniqParseCLI,
	IgnoresInput: false,
}
View Source 
var UnspaceSetup = TransformerSetup{
	Verb:         verbNameUnspace,
	UsageFunc:    transformerUnspaceUsage,
	ParseCLIFunc: transformerUnspaceParseCLI,
	IgnoresInput: false,
}
View Source 
var UnsparsifySetup = TransformerSetup{
	Verb:         verbNameUnsparsify,
	UsageFunc:    transformerUnsparsifyUsage,
	ParseCLIFunc: transformerUnsparsifyParseCLI,
	IgnoresInput: false,
}

Functions

func ChainTransformer 

func ChainTransformer(
	readerRecordChannel <-chan *list.List,
	readerDownstreamDoneChannel chan<- bool,
	recordTransformers []IRecordTransformer,
	writerRecordChannel chan<- *list.List,
	options *cli.TOptions,
)

ChainTransformer is a refinement of Miller's high-level sketch in stream.go. While stream.go sees goroutines for record reader, transformer chain, and record writer, with input channel from record-reader to transformer chain and output channel from transformer chain to record-writer, ChainTransformer subdivides goroutines for each transformer in the chain, with intermediary channels between them.

func HandleDefaultDownstreamDone 

func HandleDefaultDownstreamDone(
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

HandleDefaultDownstreamDone is a utility function for most verbs other than head, tee, and seqgen to use for passing downstream-done flags back upstream. See ChainTransformer for context.

func ListVerbNamesAsParagraph 

func ListVerbNamesAsParagraph()

func ListVerbNamesVertically 

func ListVerbNamesVertically()

func ShowHelpForTransformer 

func ShowHelpForTransformer(verb string) bool

func ShowHelpForTransformerApproximate 

func ShowHelpForTransformerApproximate(searchString string) bool

func UsageVerbs 

func UsageVerbs()

----------------------------------------------------------------

Types

type GroupingKeysAndMlrvals 

type GroupingKeysAndMlrvals struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

type IRecordTransformer 

type IRecordTransformer interface {
	Transform(
		inrecAndContext *types.RecordAndContext,
		outputRecordsAndContexts *list.List,
		inputDownstreamDoneChannel <-chan bool,
		outputDownstreamDoneChannel chan<- bool,
	)
}

IRecordTransformer is the interface satisfied by all transformers, i.e., Miller verbs. See stream.go for context on the channels, as well as for context on end-of-record-stream signaling.

func NewTransformerGsub 

func NewTransformerGsub(
	fieldNames []string,
	doAllFieldNames bool,
	doRegexes bool,
	oldText string,
	newText string,
) (IRecordTransformer, error)

func NewTransformerSsub 

func NewTransformerSsub(
	fieldNames []string,
	doAllFieldNames bool,
	doRegexes bool,
	oldText string,
	newText string,
) (IRecordTransformer, error)

func NewTransformerSub 

func NewTransformerSub(
	fieldNames []string,
	doAllFieldNames bool,
	doRegexes bool,
	oldText string,
	newText string,
) (IRecordTransformer, error)

func NewTransformerSubs 

func NewTransformerSubs(
	fieldNames []string,
	doAllFieldNames bool,
	doRegexes bool,
	oldText string,
	newText string,
	subber bifs.TernaryFunc,
) (IRecordTransformer, error)

type RecordTransformerFunc 

type RecordTransformerFunc func(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type RecordTransformerHelperFunc 

type RecordTransformerHelperFunc func(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
)

Used within some verbs

type TransformerAltkv 

type TransformerAltkv struct {
}

----------------------------------------------------------------

func NewTransformerAltkv 

func NewTransformerAltkv() (*TransformerAltkv, error)

func (*TransformerAltkv) Transform 

func (tr *TransformerAltkv) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerBar 

type TransformerBar struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerBar 

func NewTransformerBar(
	fieldNames []string,
	lo float64,
	hi float64,
	width int,
	doAuto bool,
	fillString string,
	oobString string,
	blankString string,
) (*TransformerBar, error)

----------------------------------------------------------------

func (*TransformerBar) Transform 

func (tr *TransformerBar) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerBootstrap 

type TransformerBootstrap struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerBootstrap 

func NewTransformerBootstrap(nout int64) (*TransformerBootstrap, error)

func (*TransformerBootstrap) Transform 

func (tr *TransformerBootstrap) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerCase 

type TransformerCase struct {
	// contains filtered or unexported fields
}

func NewTransformerCase 

func NewTransformerCase(
	which string,
	fieldNames []string,
	style int,
) (*TransformerCase, error)

func (*TransformerCase) Transform 

func (tr *TransformerCase) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerCat 

type TransformerCat struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerCat 

func NewTransformerCat(
	doCounters bool,
	counterFieldName string,
	groupByFieldNames []string,
	doFileName bool,
	doFileNum bool,
) (*TransformerCat, error)

----------------------------------------------------------------

func (*TransformerCat) Transform 

func (tr *TransformerCat) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerCheck 

type TransformerCheck struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerCheck 

func NewTransformerCheck() (*TransformerCheck, error)

func (*TransformerCheck) Transform 

func (tr *TransformerCheck) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerCleanWhitespace 

type TransformerCleanWhitespace struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerCleanWhitespace 

func NewTransformerCleanWhitespace(
	doKeys bool,
	doValues bool,
) (*TransformerCleanWhitespace, error)

----------------------------------------------------------------

func (*TransformerCleanWhitespace) Transform 

func (tr *TransformerCleanWhitespace) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerCount 

type TransformerCount struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerCount 

func NewTransformerCount(
	groupByFieldNames []string,
	showCountsOnly bool,
	outputFieldName string,
) (*TransformerCount, error)

func (*TransformerCount) Transform 

func (tr *TransformerCount) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerCountSimilar 

type TransformerCountSimilar struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerCountSimilar 

func NewTransformerCountSimilar(
	groupByFieldNames []string,
	counterFieldName string,
) (*TransformerCountSimilar, error)

----------------------------------------------------------------

func (*TransformerCountSimilar) Transform 

func (tr *TransformerCountSimilar) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerCut 

type TransformerCut struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerCut 

func NewTransformerCut(
	fieldNames []string,
	doArgOrder bool,
	doComplement bool,
	doRegexes bool,
) (*TransformerCut, error)

func (*TransformerCut) Transform 

func (tr *TransformerCut) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerDecimate 

type TransformerDecimate struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerDecimate 

func NewTransformerDecimate(
	decimateCount int64,
	atStart bool,
	atEnd bool,
	groupByFieldNames []string,
) (*TransformerDecimate, error)

----------------------------------------------------------------

func (*TransformerDecimate) Transform 

func (tr *TransformerDecimate) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerFillDown 

type TransformerFillDown struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerFillDown 

func NewTransformerFillDown(
	fillDownFieldNames []string,
	doAll bool,
	onlyIfAbsent bool,
) (*TransformerFillDown, error)

func (*TransformerFillDown) Transform 

func (tr *TransformerFillDown) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerFillEmpty 

type TransformerFillEmpty struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerFillEmpty 

func NewTransformerFillEmpty(
	fillString string,
	inferType bool,
) (*TransformerFillEmpty, error)

func (*TransformerFillEmpty) Transform 

func (tr *TransformerFillEmpty) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerFlatten 

type TransformerFlatten struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerFlatten 

func NewTransformerFlatten(
	oFlatSep string,
	options *cli.TOptions,
	fieldNames []string,
) (*TransformerFlatten, error)

func (*TransformerFlatten) Transform 

func (tr *TransformerFlatten) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerFormatValues 

type TransformerFormatValues struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerFormatValues 

func NewTransformerFormatValues(
	stringFormat string,
	intFormat string,
	floatFormat string,
	coerceIntToFloat bool,
) (*TransformerFormatValues, error)

func (*TransformerFormatValues) Transform 

func (tr *TransformerFormatValues) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerFraction 

type TransformerFraction struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerFraction 

func NewTransformerFraction(
	fractionFieldNames []string,
	groupByFieldNames []string,
	doPercents bool,
	doCumu bool,
) (*TransformerFraction, error)

----------------------------------------------------------------

func (*TransformerFraction) Transform 

func (tr *TransformerFraction) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerGap 

type TransformerGap struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerGap 

func NewTransformerGap(
	gapCount int64,
	groupByFieldNames []string,
) (*TransformerGap, error)

func (*TransformerGap) Transform 

func (tr *TransformerGap) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerGrep 

type TransformerGrep struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerGrep 

func NewTransformerGrep(
	regexp *regexp.Regexp,
	invert bool,
	valuesOnly bool,
) (*TransformerGrep, error)

func (*TransformerGrep) Transform 

func (tr *TransformerGrep) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerGroupBy 

type TransformerGroupBy struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerGroupBy 

func NewTransformerGroupBy(
	groupByFieldNames []string,
) (*TransformerGroupBy, error)

func (*TransformerGroupBy) Transform 

func (tr *TransformerGroupBy) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerGroupLike 

type TransformerGroupLike struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerGroupLike 

func NewTransformerGroupLike() (*TransformerGroupLike, error)

func (*TransformerGroupLike) Transform 

func (tr *TransformerGroupLike) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerHavingFields 

type TransformerHavingFields struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerHavingFields 

func NewTransformerHavingFields(
	havingFieldsCriterion tHavingFieldsCriterion,
	fieldNames []string,
	regexString string,
) (*TransformerHavingFields, error)

----------------------------------------------------------------

func (*TransformerHavingFields) Transform 

func (tr *TransformerHavingFields) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerHead 

type TransformerHead struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerHead 

func NewTransformerHead(
	headCount int64,
	groupByFieldNames []string,
) (*TransformerHead, error)

func (*TransformerHead) Transform 

func (tr *TransformerHead) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerHistogram 

type TransformerHistogram struct {
	// contains filtered or unexported fields
}

func NewTransformerHistogram 

func NewTransformerHistogram(
	valueFieldNames []string,
	lo float64,
	nbins int64,
	hi float64,
	doAuto bool,
	outputPrefix string,
) (*TransformerHistogram, error)

----------------------------------------------------------------

func (*TransformerHistogram) Transform 

func (tr *TransformerHistogram) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerJSONParse 

type TransformerJSONParse struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerJSONParse 

func NewTransformerJSONParse(
	fieldNames []string,
	keepFailed bool,
) (*TransformerJSONParse, error)

func (*TransformerJSONParse) Transform 

func (tr *TransformerJSONParse) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerJSONStringify 

type TransformerJSONStringify struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerJSONStringify 

func NewTransformerJSONStringify(
	jsonFormatting mlrval.TJSONFormatting,
	fieldNames []string,
) (*TransformerJSONStringify, error)

func (*TransformerJSONStringify) Transform 

func (tr *TransformerJSONStringify) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerJoin 

type TransformerJoin struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerJoin 

func NewTransformerJoin(
	opts *tJoinOptions,
) (*TransformerJoin, error)

----------------------------------------------------------------

func (*TransformerJoin) Transform 

func (tr *TransformerJoin) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerLabel 

type TransformerLabel struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerLabel 

func NewTransformerLabel(
	newNames []string,
) (*TransformerLabel, error)

func (*TransformerLabel) Transform 

func (tr *TransformerLabel) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerLatin1ToUTF8 

type TransformerLatin1ToUTF8 struct {
}

----------------------------------------------------------------

func NewTransformerLatin1ToUTF8 

func NewTransformerLatin1ToUTF8() (*TransformerLatin1ToUTF8, error)

func (*TransformerLatin1ToUTF8) Transform 

func (tr *TransformerLatin1ToUTF8) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerMergeFields 

type TransformerMergeFields struct {
	// contains filtered or unexported fields
}

func NewTransformerMergeFields 

func NewTransformerMergeFields(
	accumulatorNameList []string,
	valueFieldNameList []string,
	outputFieldBasename string,
	doWhich mergeByType,
	doInterpolatedPercentiles bool,
	keepInputFields bool,
) (*TransformerMergeFields, error)

func (*TransformerMergeFields) Transform 

func (tr *TransformerMergeFields) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerMostOrLeastFrequent 

type TransformerMostOrLeastFrequent struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerMostOrLeastFrequent 

func NewTransformerMostOrLeastFrequent(
	groupByFieldNames []string,
	maxOutputLength int64,
	showCounts bool,
	outputFieldName string,
	descending bool,
) (*TransformerMostOrLeastFrequent, error)

----------------------------------------------------------------

func (*TransformerMostOrLeastFrequent) Transform 

func (tr *TransformerMostOrLeastFrequent) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerNest 

type TransformerNest struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerNest 

func NewTransformerNest(
	fieldName string,
	nestedFS string,
	nestedPS string,
	doExplode bool,
	doPairs bool,
	doAcrossFields bool,
) (*TransformerNest, error)

----------------------------------------------------------------

func (*TransformerNest) Transform 

func (tr *TransformerNest) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerNothing 

type TransformerNothing struct {
}

----------------------------------------------------------------

func NewTransformerNothing 

func NewTransformerNothing() (*TransformerNothing, error)

func (*TransformerNothing) Transform 

func (tr *TransformerNothing) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerParseCLIFunc 

type TransformerParseCLIFunc func(
	pargi *int,
	argc int,
	args []string,
	mainOptions *cli.TOptions,
	doConstruct bool,
) IRecordTransformer

type TransformerPut 

type TransformerPut struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerPut 

func NewTransformerPut(
	dslStrings []string,
	dslInstanceType cst.DSLInstanceType,
	presets []string,
	echoDSLString bool,
	printASTAsTree bool,
	printASTMultiLine bool,
	printASTSingleLine bool,
	exitAfterParse bool,
	doWarnings bool,
	warningsAreFatal bool,
	strictMode bool,
	invertFilter bool,
	suppressOutputRecord bool,
	options *cli.TOptions,
) (*TransformerPut, error)

func (*TransformerPut) Transform 

func (tr *TransformerPut) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerRegularize 

type TransformerRegularize struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerRegularize 

func NewTransformerRegularize() (*TransformerRegularize, error)

func (*TransformerRegularize) Transform 

func (tr *TransformerRegularize) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerRemoveEmptyColumns 

type TransformerRemoveEmptyColumns struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerRemoveEmptyColumns 

func NewTransformerRemoveEmptyColumns() (*TransformerRemoveEmptyColumns, error)

func (*TransformerRemoveEmptyColumns) Transform 

func (tr *TransformerRemoveEmptyColumns) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerRename 

type TransformerRename struct {
	// contains filtered or unexported fields
}

func NewTransformerRename 

func NewTransformerRename(
	names []string,
	doRegexes bool,
	doGsub bool,
) (*TransformerRename, error)

func (*TransformerRename) Transform 

func (tr *TransformerRename) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerReorder 

type TransformerReorder struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerReorder 

func NewTransformerReorder(
	fieldNames []string,
	doRegexes bool,
	putAfter bool,
	centerFieldName string,
) (*TransformerReorder, error)

func (*TransformerReorder) Transform 

func (tr *TransformerReorder) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerRepeat 

type TransformerRepeat struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerRepeat 

func NewTransformerRepeat(
	repeatCountSource tRepeatCountSource,
	repeatCount int64,
	repeatCountFieldName string,
) (*TransformerRepeat, error)

----------------------------------------------------------------

func (*TransformerRepeat) Transform 

func (tr *TransformerRepeat) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerReshape 

type TransformerReshape struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerReshape 

func NewTransformerReshape(
	inputFieldNames []string,
	inputFieldRegexStrings []string,
	outputKeyFieldName string,
	outputValueFieldName string,
	splitOutKeyFieldName string,
	splitOutValueFieldName string,
) (*TransformerReshape, error)

----------------------------------------------------------------

func (*TransformerReshape) Transform 

func (tr *TransformerReshape) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSample 

type TransformerSample struct {
	// contains filtered or unexported fields
}

func NewTransformerSample 

func NewTransformerSample(
	sampleCount int64,
	groupByFieldNames []string,
) (*TransformerSample, error)

func (*TransformerSample) Transform 

func (tr *TransformerSample) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSec2GMT 

type TransformerSec2GMT struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerSec2GMT 

func NewTransformerSec2GMT(
	fieldNames string,
	preDivide float64,
	numDecimalPlaces int,
) (*TransformerSec2GMT, error)

func (*TransformerSec2GMT) Transform 

func (tr *TransformerSec2GMT) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSec2GMTDate 

type TransformerSec2GMTDate struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerSec2GMTDate 

func NewTransformerSec2GMTDate(
	fieldNames string,
) (*TransformerSec2GMTDate, error)

func (*TransformerSec2GMTDate) Transform 

func (tr *TransformerSec2GMTDate) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSeqgen 

type TransformerSeqgen struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerSeqgen 

func NewTransformerSeqgen(
	fieldName string,
	startString string,
	stopString string,
	stepString string,
) (*TransformerSeqgen, error)

----------------------------------------------------------------

func (*TransformerSeqgen) Transform 

func (tr *TransformerSeqgen) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSetup 

type TransformerSetup struct {
	Verb         string
	UsageFunc    TransformerUsageFunc
	ParseCLIFunc TransformerParseCLIFunc

	// For seqgen only -- all other transformers process records sourced by the
	// record-reader.  The seqgen verb, by contrast, is a record-source of its
	// own. (The seqgen verb probably should have been designed as a zero-file
	// record "reader" object, rather than a verb, alas.)
	IgnoresInput bool
}

func LookUp 

func LookUp(verb string) *TransformerSetup

type TransformerShuffle 

type TransformerShuffle struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerShuffle 

func NewTransformerShuffle() (*TransformerShuffle, error)

func (*TransformerShuffle) Transform 

func (tr *TransformerShuffle) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSkipTrivialRecords 

type TransformerSkipTrivialRecords struct {
}

----------------------------------------------------------------

func NewTransformerSkipTrivialRecords 

func NewTransformerSkipTrivialRecords() (*TransformerSkipTrivialRecords, error)

func (*TransformerSkipTrivialRecords) Transform 

func (tr *TransformerSkipTrivialRecords) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSort 

type TransformerSort struct {
	// contains filtered or unexported fields
}

func NewTransformerSort 

func NewTransformerSort(
	groupByFieldNames []string,
	comparatorFuncs []mlrval.CmpFuncInt,
) (*TransformerSort, error)

func (*TransformerSort) Transform 

func (tr *TransformerSort) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSortWithinRecords 

type TransformerSortWithinRecords struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerSortWithinRecords 

func NewTransformerSortWithinRecords(
	doRecurse bool,
) (*TransformerSortWithinRecords, error)

func (*TransformerSortWithinRecords) Transform 

func (tr *TransformerSortWithinRecords) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSparsify 

type TransformerSparsify struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerSparsify 

func NewTransformerSparsify(
	fillerString string,
	specifiedFieldNames []string,
) (*TransformerSparsify, error)

func (*TransformerSparsify) Transform 

func (tr *TransformerSparsify) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSplit 

type TransformerSplit struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerSplit 

func NewTransformerSplit(
	n int64,
	doMod bool,
	doSize bool,
	groupByFieldNames []string,
	emitDownstream bool,
	escapeFileNameCharacters bool,
	fileNamePartJoiner string,
	doAppend bool,
	outputFileNamePrefix string,
	outputFileNameSuffix string,
	recordWriterOptions *cli.TWriterOptions,
) (*TransformerSplit, error)

func (*TransformerSplit) Transform 

func (tr *TransformerSplit) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerStats1 

type TransformerStats1 struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerStats1 

func NewTransformerStats1(
	accumulatorNameList []string,
	valueFieldNameList []string,
	groupByFieldNameList []string,

	doRegexValueFieldNames bool,
	doRegexGroupByFieldNames bool,
	invertRegexValueFieldNames bool,
	invertRegexGroupByFieldNames bool,

	doInterpolatedPercentiles bool,
	doIterativeStats bool,
) (*TransformerStats1, error)

func (*TransformerStats1) Transform 

func (tr *TransformerStats1) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

Transform is the function executed for every input record, as well as for the end-of-stream marker.

type TransformerStats2 

type TransformerStats2 struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerStats2 

func NewTransformerStats2(
	accumulatorNameList []string,
	valueFieldNameList []string,
	groupByFieldNameList []string,
	doVerbose bool,
	doIterativeStats bool,
	doHoldAndFit bool,
) (*TransformerStats2, error)

func (*TransformerStats2) Transform 

func (tr *TransformerStats2) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerStep 

type TransformerStep struct {
	// contains filtered or unexported fields
}

func NewTransformerStep 

func NewTransformerStep(
	stepperInputs []*tStepperInput,
	valueFieldNames []string,
	groupByFieldNames []string,
	stringAlphas []string,
	ewmaSuffixes []string,
) (*TransformerStep, error)

func (*TransformerStep) Transform 

func (tr *TransformerStep) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSubs 

type TransformerSubs struct {
	// contains filtered or unexported fields
}

func (*TransformerSubs) Transform 

func (tr *TransformerSubs) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerSummary 

type TransformerSummary struct {
	// contains filtered or unexported fields
}

func NewTransformerSummary 

func NewTransformerSummary(
	summarizerNames []string,
	transposeOutput bool,
) (*TransformerSummary, error)

func (*TransformerSummary) Transform 

func (tr *TransformerSummary) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerTac 

type TransformerTac struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerTac 

func NewTransformerTac() (*TransformerTac, error)

func (*TransformerTac) Transform 

func (tr *TransformerTac) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerTail 

type TransformerTail struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerTail 

func NewTransformerTail(
	tailCount int64,
	groupByFieldNames []string,
) (*TransformerTail, error)

func (*TransformerTail) Transform 

func (tr *TransformerTail) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerTee 

type TransformerTee struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerTee 

func NewTransformerTee(
	appending bool,
	piping bool,
	filenameOrCommand string,
	recordWriterOptions *cli.TWriterOptions,
) (*TransformerTee, error)

func (*TransformerTee) Transform 

func (tr *TransformerTee) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerTemplate 

type TransformerTemplate struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerTemplate 

func NewTransformerTemplate(
	fieldNames []string,
	fillWith string,
) (*TransformerTemplate, error)

func (*TransformerTemplate) Transform 

func (tr *TransformerTemplate) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerTop 

type TransformerTop struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerTop 

func NewTransformerTop(
	topCount int64,
	valueFieldNames []string,
	groupByFieldNames []string,
	showFullRecords bool,
	doMax bool,
	outputFieldName string,
) (*TransformerTop, error)

----------------------------------------------------------------

func (*TransformerTop) Transform 

func (tr *TransformerTop) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerUTF8ToLatin1 

type TransformerUTF8ToLatin1 struct {
}

----------------------------------------------------------------

func NewTransformerUTF8ToLatin1 

func NewTransformerUTF8ToLatin1() (*TransformerUTF8ToLatin1, error)

func (*TransformerUTF8ToLatin1) Transform 

func (tr *TransformerUTF8ToLatin1) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerUnflatten 

type TransformerUnflatten struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerUnflatten 

func NewTransformerUnflatten(
	oFlatSep string,
	options *cli.TOptions,
	fieldNames []string,
) (*TransformerUnflatten, error)

func (*TransformerUnflatten) Transform 

func (tr *TransformerUnflatten) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerUniq 

type TransformerUniq struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerUniq 

func NewTransformerUniq(
	fieldNames []string,
	invertFieldNames bool,
	showCounts bool,
	showNumDistinctOnly bool,
	outputFieldName string,
	doLashed bool,
	uniqifyEntireRecords bool,
) (*TransformerUniq, error)

----------------------------------------------------------------

func (*TransformerUniq) Transform 

func (tr *TransformerUniq) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerUnspace 

type TransformerUnspace struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerUnspace 

func NewTransformerUnspace(
	filler string,
	which string,
) (*TransformerUnspace, error)

func (*TransformerUnspace) Transform 

func (tr *TransformerUnspace) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerUnsparsify 

type TransformerUnsparsify struct {
	// contains filtered or unexported fields
}

----------------------------------------------------------------

func NewTransformerUnsparsify 

func NewTransformerUnsparsify(
	fillerString string,
	specifiedFieldNames []string,
) (*TransformerUnsparsify, error)

func (*TransformerUnsparsify) Transform 

func (tr *TransformerUnsparsify) Transform(
	inrecAndContext *types.RecordAndContext,
	outputRecordsAndContexts *list.List,
	inputDownstreamDoneChannel <-chan bool,
	outputDownstreamDoneChannel chan<- bool,
)

type TransformerUsageFunc 

type TransformerUsageFunc func(
	ostream *os.File,
)

Source Files

View all Source files

Directories

Path Synopsis
Package utils holds data structures used by various verbs including join,stats1, and top within package transforming.
 Package utils holds data structures used by various verbs including join,stats1, and top within package transforming.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.