package dynparquet

Import Path
	github.com/polarsignals/frostdb/dynparquet (on go.dev)

Dependency Relation
	imports 25 packages, and imported by 7 packages

Involved Source Files

	    concat.go
	    dynamiccolumns.go
	    example.go
	    hashed.go
	    nil_chunk.go
	    reader.go
	    row.go
	    schema.go
Package-Level Type Names (total 21)

	/* sort by: alphabet | popularity */
	 type Buffer (struct)
		Buffer represents an batch of rows with a concrete set of dynamic column
		names representing how its parquet schema was created off of a dynamic
		parquet schema.

		Methods (total 14)
			(*Buffer) Clone() (*Buffer, error)
			(*Buffer) ColumnChunks() []parquet.ColumnChunk
				ColumnChunks returns the list of parquet.ColumnChunk for the given index.
				It contains all the pages associated with this row group's column.
				Implements the parquet.RowGroup interface.

			(*Buffer) DynamicColumns() map[string][]string
				DynamicColumns returns the concrete dynamic column names of the buffer. It
				implements the DynamicRowGroup interface.

			(*Buffer) DynamicRows() DynamicRowReader
				DynamicRows returns an iterator for the rows in the buffer. It implements the
				DynamicRowGroup interface.

			(*Buffer) NumRows() int64
				NumRows returns the number of rows in the buffer. Implements the
				parquet.RowGroup interface.

			(*Buffer) Reset()
			(*Buffer) Rows() parquet.Rows
				Rows returns an iterator for the rows in the buffer. It implements the
				parquet.RowGroup interface.

			(*Buffer) Schema() *parquet.Schema
				Schema returns the concrete parquet.Schema of the buffer. Implements the
				parquet.RowGroup interface.

			(*Buffer) Size() int64
			(*Buffer) Sort()
			(*Buffer) SortingColumns() []parquet.SortingColumn
				SortingColumns returns the concrete slice of parquet.SortingColumns of the
				buffer. Implements the parquet.RowGroup interface.

			(*Buffer) String() string
			(*Buffer) WriteRowGroup(rg parquet.RowGroup) (int64, error)
				WriteRowGroup writes a single row to the buffer.

			(*Buffer) WriteRows(rows []parquet.Row) (int, error)
				WriteRow writes a single row to the buffer.

		Implements (at least 8)
			*Buffer : DynamicRowGroup
			*Buffer : github.com/polarsignals/frostdb/query/expr.Particulate
			*Buffer : github.com/parquet-go/parquet-go.RowGroup
			*Buffer : github.com/parquet-go/parquet-go.RowGroupWriter
			*Buffer : github.com/parquet-go/parquet-go.RowWriter
			*Buffer : github.com/parquet-go/parquet-go.RowWriterWithSchema
			*Buffer : expvar.Var
			*Buffer : fmt.Stringer
		As Outputs Of (at least 4)
			func ToBuffer(s Samples, schema *Schema) (*Buffer, error)
			func (*Buffer).Clone() (*Buffer, error)
			func (*Schema).NewBuffer(dynamicColumns map[string][]string) (*Buffer, error)
			func (*Schema).NewBufferV2(dynamicColumns ...*schemav2pb.Node) (*Buffer, error)
		As Inputs Of (at least one exported)
			func (*Schema).SerializeBuffer(w io.Writer, buffer *Buffer) error

	 type ColumnDefinition (struct)
		ColumnDefinition describes a column in a dynamic parquet schema.

		Fields (total 4)
			Dynamic bool
			Name string
			PreHash bool
			StorageLayout parquet.Node
		As Outputs Of (at least 6)
			func (*Schema).ColumnByName(name string) (ColumnDefinition, bool)
			func (*Schema).ColumnDefinitionsForSortingColumns() []ColumnDefinition
			func (*Schema).Columns() []ColumnDefinition
			func (*Schema).FindColumn(column string) (ColumnDefinition, bool)
			func (*Schema).FindDynamicColumn(dynamicColumnName string) (ColumnDefinition, bool)
			func (*Schema).FindDynamicColumnForConcreteColumn(column string) (ColumnDefinition, bool)

	 type DynamicRow (struct)

		Fields (total 3)
			DynamicColumns map[string][]string
			Row parquet.Row
			Schema *parquet.Schema
		As Outputs Of (at least 6)
			func NewDynamicRow(row parquet.Row, schema *parquet.Schema, dyncols map[string][]string, fields []parquet.Field) *DynamicRow
			func (*DynamicRows).Get(i int) *DynamicRow
			func (*DynamicRows).GetCopy(i int) *DynamicRow
			func github.com/polarsignals/frostdb/parts.Part.Least() (*DynamicRow, error)
			func github.com/polarsignals/frostdb/parts.Part.Most() (*DynamicRow, error)
			func github.com/polarsignals/frostdb/pqarrow.RecordToDynamicRow(pqSchema *parquet.Schema, record arrow.Record, dyncols map[string][]string, index int) (*DynamicRow, error)
		As Inputs Of (at least 2)
			func (*Schema).Cmp(a, b *DynamicRow) int
			func (*Schema).RowLessThan(a, b *DynamicRow) bool

	 type DynamicRowGroup (interface)
		DynamicRowGroup is a parquet.RowGroup that can describe the concrete dynamic
		columns.

		Methods (total 8)
			( DynamicRowGroup) ColumnChunks() []parquet.ColumnChunk
				Returns the list of column chunks in this row group. The chunks are
				ordered in the order of leaf columns from the row group's schema.
				
				If the underlying implementation is not read-only, the returned
				parquet.ColumnChunk may implement other interfaces: for example,
				parquet.ColumnBuffer if the chunk is backed by an in-memory buffer,
				or typed writer interfaces like parquet.Int32Writer depending on the
				underlying type of values that can be written to the chunk.
				
				As an optimization, the row group may return the same slice across
				multiple calls to this method. Applications should treat the returned
				slice as read-only.

			( DynamicRowGroup) DynamicColumns() map[string][]string
				DynamicColumns returns the concrete dynamic column names that were used
				create its concrete parquet schema with a dynamic parquet schema.

			( DynamicRowGroup) DynamicRows() DynamicRowReader
				DynamicRows return an iterator over the rows in the row group.

			( DynamicRowGroup) NumRows() int64
				Returns the number of rows in the group.

			( DynamicRowGroup) Rows() parquet.Rows
				Returns a reader exposing the rows of the row group.
				
				As an optimization, the returned parquet.Rows object may implement
				parquet.RowWriterTo, and test the RowWriter it receives for an
				implementation of the parquet.RowGroupWriter interface.
				
				This optimization mechanism is leveraged by the parquet.CopyRows function
				to skip the generic row-by-row copy algorithm and delegate the copy logic
				to the parquet.Rows object.

			( DynamicRowGroup) Schema() *parquet.Schema
				Returns the schema of rows in the group.

			( DynamicRowGroup) SortingColumns() []parquet.SortingColumn
				Returns the list of sorting columns describing how rows are sorted in the
				group.
				
				The method will return an empty slice if the rows are not sorted.

			( DynamicRowGroup) String() string
		Implemented By (at least 4)
			*Buffer
			*MergedRowGroup
			 PooledBuffer
			 github.com/polarsignals/frostdb/index.ReleaseableRowGroup (interface)
		Implements (at least 4)
			 DynamicRowGroup : github.com/polarsignals/frostdb/query/expr.Particulate
			 DynamicRowGroup : github.com/parquet-go/parquet-go.RowGroup
			 DynamicRowGroup : expvar.Var
			 DynamicRowGroup : fmt.Stringer
		As Outputs Of (at least 4)
			func Concat(fields []parquet.Field, drg ...DynamicRowGroup) DynamicRowGroup
			func (*Schema).MergeDynamicRowGroups(rowGroups []DynamicRowGroup, options ...MergeOption) (DynamicRowGroup, error)
			func (*SerializedBuffer).DynamicRowGroup(i int) DynamicRowGroup
			func (*SerializedBuffer).MultiDynamicRowGroup() DynamicRowGroup
		As Inputs Of (at least 2)
			func Concat(fields []parquet.Field, drg ...DynamicRowGroup) DynamicRowGroup
			func (*Schema).MergeDynamicRowGroups(rowGroups []DynamicRowGroup, options ...MergeOption) (DynamicRowGroup, error)

	 type DynamicRowGroupMergeAdapter (struct)
		DynamicRowGroupMergeAdapter maps a RowBatch with a Schema with a subset of dynamic
		columns to a Schema with a superset of dynamic columns. It implements the
		parquet.RowGroup interface.

		Methods (total 5)
			(*DynamicRowGroupMergeAdapter) ColumnChunks() []parquet.ColumnChunk
				Returns the leaf column at the given index in the group. Searches for the
				same column in the original batch. If not found returns a column chunk
				filled with nulls.

			(*DynamicRowGroupMergeAdapter) NumRows() int64
				Returns the number of rows in the group.

			(*DynamicRowGroupMergeAdapter) Rows() parquet.Rows
				Returns a reader exposing the rows of the row group.

			(*DynamicRowGroupMergeAdapter) Schema() *parquet.Schema
				Returns the schema of rows in the group. The schema is the configured
				merged, superset schema.

			(*DynamicRowGroupMergeAdapter) SortingColumns() []parquet.SortingColumn
				Returns the list of sorting columns describing how rows are sorted in the
				group.
				
				The method will return an empty slice if the rows are not sorted.

		Implements (at least 2)
			*DynamicRowGroupMergeAdapter : github.com/polarsignals/frostdb/query/expr.Particulate
			*DynamicRowGroupMergeAdapter : github.com/parquet-go/parquet-go.RowGroup
		As Outputs Of (at least one exported)
			func NewDynamicRowGroupMergeAdapter(schema *parquet.Schema, sortingColumns []parquet.SortingColumn, mergedDynamicColumns map[string][]string, originalRowGroup parquet.RowGroup) *DynamicRowGroupMergeAdapter

	 type DynamicRowReader (interface)
		DynamicRowReader is an iterator over the rows in a DynamicRowGroup.

		Methods (total 3)
			( DynamicRowReader) Close() error
			( DynamicRowReader) ReadRows(*DynamicRows) (int, error)
			( DynamicRowReader) SeekToRow(int64) error
				Positions the stream on the given row index.
				
				Some implementations of the interface may only allow seeking forward.
				
				The method returns io.ErrClosedPipe if the stream had already been closed.

		Implements (at least 3)
			 DynamicRowReader : github.com/parquet-go/parquet-go.RowSeeker
			 DynamicRowReader : github.com/prometheus/common/expfmt.Closer
			 DynamicRowReader : io.Closer
		As Outputs Of (at least 5)
			func (*Buffer).DynamicRows() DynamicRowReader
			func DynamicRowGroup.DynamicRows() DynamicRowReader
			func (*MergedRowGroup).DynamicRows() DynamicRowReader
			func (*SerializedBuffer).DynamicRows() DynamicRowReader
			func github.com/polarsignals/frostdb/index.ReleaseableRowGroup.DynamicRows() DynamicRowReader

	 type DynamicRows (struct)

		Fields (total 3)
			DynamicColumns map[string][]string
			Rows []parquet.Row
			Schema *parquet.Schema
		Methods (total 3)
			(*DynamicRows) Get(i int) *DynamicRow
			(*DynamicRows) GetCopy(i int) *DynamicRow
			(*DynamicRows) IsSorted(schema *Schema) bool
		As Outputs Of (at least one exported)
			func NewDynamicRows(rows []parquet.Row, schema *parquet.Schema, dynamicColumns map[string][]string, fields []parquet.Field) *DynamicRows
		As Inputs Of (at least 2)
			func NewDynamicRowSorter(schema *Schema, rows *DynamicRows) *DynamicRowSorter
			func DynamicRowReader.ReadRows(*DynamicRows) (int, error)

	 type DynamicRowSorter (struct)

		Methods (total 3)
			(*DynamicRowSorter) Len() int
			(*DynamicRowSorter) Less(i, j int) bool
			(*DynamicRowSorter) Swap(i, j int)
		Implements (at least one exported)
			*DynamicRowSorter : sort.Interface
		As Outputs Of (at least one exported)
			func NewDynamicRowSorter(schema *Schema, rows *DynamicRows) *DynamicRowSorter

	 type MergedRowGroup (struct)
		MergedRowGroup allows wrapping any parquet.RowGroup to implement the
		DynamicRowGroup interface by specifying the concrete dynamic column names
		the RowGroup's schema contains.

		Fields (total 2)
			DynCols map[string][]string
			RowGroup parquet.RowGroup
		Methods (total 8)
			( MergedRowGroup) ColumnChunks() []parquet.ColumnChunk
				Returns the list of column chunks in this row group. The chunks are
				ordered in the order of leaf columns from the row group's schema.
				
				If the underlying implementation is not read-only, the returned
				parquet.ColumnChunk may implement other interfaces: for example,
				parquet.ColumnBuffer if the chunk is backed by an in-memory buffer,
				or typed writer interfaces like parquet.Int32Writer depending on the
				underlying type of values that can be written to the chunk.
				
				As an optimization, the row group may return the same slice across
				multiple calls to this method. Applications should treat the returned
				slice as read-only.

			(*MergedRowGroup) DynamicColumns() map[string][]string
				DynamicColumns returns the concrete dynamic column names that were used
				create its concrete parquet schema with a dynamic parquet schema. Implements
				the DynamicRowGroup interface.

			(*MergedRowGroup) DynamicRows() DynamicRowReader
				DynamicRows returns an iterator over the rows in the row group. Implements
				the DynamicRowGroup interface.

			( MergedRowGroup) NumRows() int64
				Returns the number of rows in the group.

			( MergedRowGroup) Rows() parquet.Rows
				Returns a reader exposing the rows of the row group.
				
				As an optimization, the returned parquet.Rows object may implement
				parquet.RowWriterTo, and test the RowWriter it receives for an
				implementation of the parquet.RowGroupWriter interface.
				
				This optimization mechanism is leveraged by the parquet.CopyRows function
				to skip the generic row-by-row copy algorithm and delegate the copy logic
				to the parquet.Rows object.

			( MergedRowGroup) Schema() *parquet.Schema
				Returns the schema of rows in the group.

			( MergedRowGroup) SortingColumns() []parquet.SortingColumn
				Returns the list of sorting columns describing how rows are sorted in the
				group.
				
				The method will return an empty slice if the rows are not sorted.

			(*MergedRowGroup) String() string
		Implements (at least 5)
			*MergedRowGroup : DynamicRowGroup
			 MergedRowGroup : github.com/polarsignals/frostdb/query/expr.Particulate
			 MergedRowGroup : github.com/parquet-go/parquet-go.RowGroup
			*MergedRowGroup : expvar.Var
			*MergedRowGroup : fmt.Stringer

	 type MergeOption (func)

		As Outputs Of (at least 2)
			func WithAlreadySorted() MergeOption
			func WithDynamicCols(cols map[string][]string) MergeOption
		As Inputs Of (at least one exported)
			func (*Schema).MergeDynamicRowGroups(rowGroups []DynamicRowGroup, options ...MergeOption) (DynamicRowGroup, error)

	 type NilColumnChunk (struct)
		NilColumnChunk is a column chunk that contains a single page with all null
		values of the given type, given length and column index of the parent
		schema. It implements the parquet.ColumnChunk interface.

		Methods (total 7)
			(*NilColumnChunk) BloomFilter() parquet.BloomFilter
				BloomFilter returns the bloomfilter of the column chunk. Since the
				NilColumnChunk is a virtual column chunk only for in-memory purposes, it
				returns nil. Implements the parquet.ColumnChunk interface.

			(*NilColumnChunk) Column() int
				Type returns the index of the column chunk within the parent schema.
				Implements the parquet.ColumnChunk interface.

			(*NilColumnChunk) ColumnIndex() (parquet.ColumnIndex, error)
				ColumnIndex returns the column index of the column chunk. Since the
				NilColumnChunk is a virtual column chunk only for in-memory purposes, it
				returns nil. Implements the parquet.ColumnChunk interface.

			(*NilColumnChunk) NumValues() int64
				NumValues returns the number of values in the column chunk. Implements the
				parquet.ColumnChunk interface.

			(*NilColumnChunk) OffsetIndex() (parquet.OffsetIndex, error)
				OffsetIndex returns the offset index of the column chunk. Since the
				NilColumnChunk is a virtual column chunk only for in-memory purposes, it
				returns nil. Implements the parquet.ColumnChunk interface.

			(*NilColumnChunk) Pages() parquet.Pages
				Pages returns an iterator for all pages within the column chunk. This
				iterator will only ever return a single page filled with all null values of
				the configured amount. Implements the parquet.ColumnChunk interface.

			(*NilColumnChunk) Type() parquet.Type
				Type returns the type of the column chunk. Implements the
				parquet.ColumnChunk interface.

		Implements (at least one exported)
			*NilColumnChunk : github.com/parquet-go/parquet-go.ColumnChunk
		As Outputs Of (at least one exported)
			func NewNilColumnChunk(typ parquet.Type, columnIndex, numValues int) *NilColumnChunk

	 type ParquetWriter (interface)

		Methods (total 6)
			( ParquetWriter) Close() error
			( ParquetWriter) Flush() error
			( ParquetWriter) Reset(writer io.Writer)
			( ParquetWriter) Schema() *parquet.Schema
			( ParquetWriter) Write(rows []any) (int, error)
			( ParquetWriter) WriteRows(rows []parquet.Row) (int, error)
		Implemented By (at least one exported)
			 PooledWriter
		Implements (at least 6)
			 ParquetWriter : github.com/polarsignals/frostdb.ParquetWriter
			 ParquetWriter : github.com/apache/thrift/lib/go/thrift.Flusher
			 ParquetWriter : github.com/parquet-go/parquet-go.RowWriter
			 ParquetWriter : github.com/parquet-go/parquet-go.RowWriterWithSchema
			 ParquetWriter : github.com/prometheus/common/expfmt.Closer
			 ParquetWriter : io.Closer
		As Outputs Of (at least one exported)
			func (*Schema).NewWriter(w io.Writer, dynamicColumns map[string][]string, sorting bool, options ...parquet.WriterOption) (ParquetWriter, error)
		As Inputs Of (at least 3)
			func github.com/polarsignals/frostdb/parts.Part.SerializeBuffer(schema *Schema, w ParquetWriter) error
			func github.com/polarsignals/frostdb/pqarrow.RecordsToFile(schema *Schema, w ParquetWriter, recs []arrow.Record) error
			func github.com/polarsignals/frostdb/pqarrow.RecordToFile(schema *Schema, w ParquetWriter, r arrow.Record) error

	 type PooledBuffer (struct)

		Fields (only one)
			Buffer *Buffer
		Methods (total 14)
			( PooledBuffer) Clone() (*Buffer, error)
			( PooledBuffer) ColumnChunks() []parquet.ColumnChunk
				ColumnChunks returns the list of parquet.ColumnChunk for the given index.
				It contains all the pages associated with this row group's column.
				Implements the parquet.RowGroup interface.

			( PooledBuffer) DynamicColumns() map[string][]string
				DynamicColumns returns the concrete dynamic column names of the buffer. It
				implements the DynamicRowGroup interface.

			( PooledBuffer) DynamicRows() DynamicRowReader
				DynamicRows returns an iterator for the rows in the buffer. It implements the
				DynamicRowGroup interface.

			( PooledBuffer) NumRows() int64
				NumRows returns the number of rows in the buffer. Implements the
				parquet.RowGroup interface.

			( PooledBuffer) Reset()
			( PooledBuffer) Rows() parquet.Rows
				Rows returns an iterator for the rows in the buffer. It implements the
				parquet.RowGroup interface.

			( PooledBuffer) Schema() *parquet.Schema
				Schema returns the concrete parquet.Schema of the buffer. Implements the
				parquet.RowGroup interface.

			( PooledBuffer) Size() int64
			( PooledBuffer) Sort()
			( PooledBuffer) SortingColumns() []parquet.SortingColumn
				SortingColumns returns the concrete slice of parquet.SortingColumns of the
				buffer. Implements the parquet.RowGroup interface.

			( PooledBuffer) String() string
			( PooledBuffer) WriteRowGroup(rg parquet.RowGroup) (int64, error)
				WriteRowGroup writes a single row to the buffer.

			( PooledBuffer) WriteRows(rows []parquet.Row) (int, error)
				WriteRow writes a single row to the buffer.

		Implements (at least 8)
			 PooledBuffer : DynamicRowGroup
			 PooledBuffer : github.com/polarsignals/frostdb/query/expr.Particulate
			 PooledBuffer : github.com/parquet-go/parquet-go.RowGroup
			 PooledBuffer : github.com/parquet-go/parquet-go.RowGroupWriter
			 PooledBuffer : github.com/parquet-go/parquet-go.RowWriter
			 PooledBuffer : github.com/parquet-go/parquet-go.RowWriterWithSchema
			 PooledBuffer : expvar.Var
			 PooledBuffer : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*Schema).GetBuffer(dynamicColumns map[string][]string) (*PooledBuffer, error)
		As Inputs Of (at least one exported)
			func (*Schema).PutBuffer(b *PooledBuffer)

	 type PooledParquetSchema (struct)

		Fields (only one)
			Schema *parquet.Schema
		As Outputs Of (at least 2)
			func (*Schema).GetDynamicParquetSchema(dynamicColumns map[string][]string) (*PooledParquetSchema, error)
			func (*Schema).GetParquetSortingSchema(dynamicColumns map[string][]string) (*PooledParquetSchema, error)
		As Inputs Of (at least one exported)
			func (*Schema).PutPooledParquetSchema(ps *PooledParquetSchema)

	 type PooledWriter (struct)

		Fields (only one)
			ParquetWriter ParquetWriter
		Methods (total 6)
			( PooledWriter) Close() error
			( PooledWriter) Flush() error
			( PooledWriter) Reset(writer io.Writer)
			( PooledWriter) Schema() *parquet.Schema
			( PooledWriter) Write(rows []any) (int, error)
			( PooledWriter) WriteRows(rows []parquet.Row) (int, error)
		Implements (at least 7)
			 PooledWriter : ParquetWriter
			 PooledWriter : github.com/polarsignals/frostdb.ParquetWriter
			 PooledWriter : github.com/apache/thrift/lib/go/thrift.Flusher
			 PooledWriter : github.com/parquet-go/parquet-go.RowWriter
			 PooledWriter : github.com/parquet-go/parquet-go.RowWriterWithSchema
			 PooledWriter : github.com/prometheus/common/expfmt.Closer
			 PooledWriter : io.Closer
		As Outputs Of (at least one exported)
			func (*Schema).GetWriter(w io.Writer, dynamicColumns map[string][]string, sorting bool) (*PooledWriter, error)
		As Inputs Of (at least one exported)
			func (*Schema).PutWriter(w *PooledWriter)

	 type Sample = samples.Sample (struct)
	 type Samples = samples.Samples ([])
	 type Schema (struct)
		Schema is a dynamic parquet schema. It extends a parquet schema with the
		ability that any column definition that is dynamic will have columns
		dynamically created as their column name is seen for the first time.

		Fields (only one)
			UniquePrimaryIndex bool
		Methods (total 27)
			(*Schema) Cmp(a, b *DynamicRow) int
			(*Schema) ColumnByName(name string) (ColumnDefinition, bool)
			(*Schema) ColumnDefinitionsForSortingColumns() []ColumnDefinition
			(*Schema) Columns() []ColumnDefinition
			(*Schema) Definition() proto.Message
			(*Schema) FindColumn(column string) (ColumnDefinition, bool)
				FindColumn returns a column definition for the column passed.

			(*Schema) FindDynamicColumn(dynamicColumnName string) (ColumnDefinition, bool)
				FindDynamicColumn returns a dynamic column definition for the column passed.

			(*Schema) FindDynamicColumnForConcreteColumn(column string) (ColumnDefinition, bool)
				FindDynamicColumnForConcreteColumn returns a column definition for the
				column passed. So "labels.label1" would return the column definition for the
				dynamic column "labels" if it exists.

			(*Schema) GetBuffer(dynamicColumns map[string][]string) (*PooledBuffer, error)
			(*Schema) GetDynamicParquetSchema(dynamicColumns map[string][]string) (*PooledParquetSchema, error)
				GetDynamicParquetSchema returns a parquet schema of the all columns and
				the given dynamic columns.
				The difference with GetParquetSortingSchema is that all columns are included
				in the parquet schema.

			(*Schema) GetParquetSortingSchema(dynamicColumns map[string][]string) (*PooledParquetSchema, error)
				GetParquetSortingSchema returns a parquet schema of the sorting columns and
				the given dynamic columns.
				The difference with GetDynamicParquetSchema is that non-sorting columns are elided.

			(*Schema) GetWriter(w io.Writer, dynamicColumns map[string][]string, sorting bool) (*PooledWriter, error)
			(*Schema) MergeDynamicRowGroups(rowGroups []DynamicRowGroup, options ...MergeOption) (DynamicRowGroup, error)
				MergeDynamicRowGroups merges the given dynamic row groups into a single
				dynamic row group. It merges the parquet schema in a non-conflicting way by
				merging all the concrete dynamic column names and generating a superset
				parquet schema that all given dynamic row groups are compatible with.

			(*Schema) Name() string
			(*Schema) NewBuffer(dynamicColumns map[string][]string) (*Buffer, error)
				NewBuffer returns a new buffer with a concrete parquet schema generated
				using the given concrete dynamic column names.

			(*Schema) NewBufferV2(dynamicColumns ...*schemav2pb.Node) (*Buffer, error)
			(*Schema) NewWriter(w io.Writer, dynamicColumns map[string][]string, sorting bool, options ...parquet.WriterOption) (ParquetWriter, error)
				NewWriter returns a new parquet writer with a concrete parquet schema
				generated using the given concrete dynamic column names.

			(*Schema) ParquetSchema() *parquet.Schema
			( Schema) ParquetSortingColumns(dynamicColumns map[string][]string) []parquet.SortingColumn
				ParquetSortingColumns returns the parquet sorting columns for the dynamic
				sorting columns with the concrete dynamic column names given in the
				argument.

			(*Schema) PutBuffer(b *PooledBuffer)
			(*Schema) PutPooledParquetSchema(ps *PooledParquetSchema)
			(*Schema) PutWriter(w *PooledWriter)
			(*Schema) ResetBuffers()
			(*Schema) ResetWriters()
			(*Schema) RowLessThan(a, b *DynamicRow) bool
			(*Schema) SerializeBuffer(w io.Writer, buffer *Buffer) error
			(*Schema) SortingColumns() []SortingColumn
		Implements (at least one exported)
			*Schema : github.com/polarsignals/frostdb/query/logicalplan.Named
		As Outputs Of (at least 6)
			func NewSampleSchema() *Schema
			func SchemaFromDefinition(msg proto.Message) (*Schema, error)
			func SchemaFromParquetFile(file *parquet.File) (*Schema, error)
			func github.com/polarsignals/frostdb.(*Table).Schema() *Schema
			func github.com/polarsignals/frostdb/query/logicalplan.(*LogicalPlan).InputSchema() *Schema
			func github.com/polarsignals/frostdb/query/logicalplan.TableReader.Schema() *Schema
		As Inputs Of (at least 24)
			func NewDynamicRowSorter(schema *Schema, rows *DynamicRows) *DynamicRowSorter
			func PrehashColumns(schema *Schema, r arrow.Record) arrow.Record
			func ToBuffer(s Samples, schema *Schema) (*Buffer, error)
			func (*DynamicRows).IsSorted(schema *Schema) bool
			func github.com/polarsignals/frostdb.DataSinkSource.Scan(ctx context.Context, prefix string, schema *Schema, filter logicalplan.Expr, lastBlockTimestamp uint64, callback func(context.Context, any) error) error
			func github.com/polarsignals/frostdb.DataSource.Scan(ctx context.Context, prefix string, schema *Schema, filter logicalplan.Expr, lastBlockTimestamp uint64, callback func(context.Context, any) error) error
			func github.com/polarsignals/frostdb.(*DefaultObjstoreBucket).Scan(ctx context.Context, prefix string, _ *Schema, filter logicalplan.Expr, lastBlockTimestamp uint64, callback func(context.Context, any) error) error
			func github.com/polarsignals/frostdb/index.NewLSM(dir string, schema *Schema, levels []*index.LevelConfig, watermark func() uint64, options ...index.LSMOption) (*index.LSM, error)
			func github.com/polarsignals/frostdb/index.(*LSM).Scan(ctx context.Context, _ string, _ *Schema, filter logicalplan.Expr, tx uint64, callback func(context.Context, any) error) error
			func github.com/polarsignals/frostdb/parts.FindMaximumNonOverlappingSet(schema *Schema, parts []parts.Part) ([]parts.Part, []parts.Part, error)
			func github.com/polarsignals/frostdb/parts.NewArrowPart(tx uint64, record arrow.Record, size uint64, schema *Schema, options ...parts.Option) parts.Part
			func github.com/polarsignals/frostdb/parts.NewPartSorter(schema *Schema, parts []parts.Part) *parts.PartSorter
			func github.com/polarsignals/frostdb/parts.Part.AsSerializedBuffer(schema *Schema) (*SerializedBuffer, error)
			func github.com/polarsignals/frostdb/parts.Part.OverlapsWith(schema *Schema, otherPart parts.Part) (bool, error)
			func github.com/polarsignals/frostdb/parts.Part.SerializeBuffer(schema *Schema, w ParquetWriter) error
			func github.com/polarsignals/frostdb/pqarrow.ParquetRowGroupToArrowSchema(ctx context.Context, rg parquet.RowGroup, s *Schema, options logicalplan.IterOptions) (*arrow.Schema, error)
			func github.com/polarsignals/frostdb/pqarrow.ParquetSchemaToArrowSchema(ctx context.Context, schema *parquet.Schema, s *Schema, options logicalplan.IterOptions) (*arrow.Schema, error)
			func github.com/polarsignals/frostdb/pqarrow.RecordsToFile(schema *Schema, w ParquetWriter, recs []arrow.Record) error
			func github.com/polarsignals/frostdb/pqarrow.RecordToFile(schema *Schema, w ParquetWriter, r arrow.Record) error
			func github.com/polarsignals/frostdb/pqarrow.SerializeRecord(r arrow.Record, schema *Schema) (*SerializedBuffer, error)
			func github.com/polarsignals/frostdb/pqarrow.(*ParquetConverter).Convert(ctx context.Context, rg parquet.RowGroup, s *Schema) error
			func github.com/polarsignals/frostdb/query/logicalplan.DataTypeForExprWithSchema(expr logicalplan.Expr, s *Schema) (arrow.DataType, error)
			func github.com/polarsignals/frostdb/query/physicalplan.Build(ctx context.Context, pool memory.Allocator, tracer trace.Tracer, s *Schema, plan *logicalplan.LogicalPlan, options ...physicalplan.Option) (*physicalplan.OutputPlan, error)
			func github.com/polarsignals/frostdb/storage.(*Iceberg).Scan(ctx context.Context, prefix string, _ *Schema, filter logicalplan.Expr, _ uint64, callback func(context.Context, any) error) error

	 type SerializedBuffer (struct)

		Methods (total 9)
			(*SerializedBuffer) DynamicColumns() map[string][]string
			(*SerializedBuffer) DynamicRowGroup(i int) DynamicRowGroup
			(*SerializedBuffer) DynamicRows() DynamicRowReader
			(*SerializedBuffer) MultiDynamicRowGroup() DynamicRowGroup
				MultiDynamicRowGroup returns all the row groups wrapped in a single multi
				row group.

			(*SerializedBuffer) NumRowGroups() int
			(*SerializedBuffer) NumRows() int64
			(*SerializedBuffer) ParquetFile() *parquet.File
			(*SerializedBuffer) Reader() *parquet.GenericReader[any]
			(*SerializedBuffer) String() string
		Implements (at least 2)
			*SerializedBuffer : expvar.Var
			*SerializedBuffer : fmt.Stringer
		As Outputs Of (at least 4)
			func NewSerializedBuffer(f *parquet.File) (*SerializedBuffer, error)
			func ReaderFromBytes(buf []byte) (*SerializedBuffer, error)
			func github.com/polarsignals/frostdb/parts.Part.AsSerializedBuffer(schema *Schema) (*SerializedBuffer, error)
			func github.com/polarsignals/frostdb/pqarrow.SerializeRecord(r arrow.Record, schema *Schema) (*SerializedBuffer, error)
		As Inputs Of (at least one exported)
			func github.com/polarsignals/frostdb/parts.NewParquetPart(tx uint64, buf *SerializedBuffer, options ...parts.Option) parts.Part

	 type SortingColumn (interface)
		SortingColumn describes a column to sort by in a dynamic parquet schema.

		Methods (total 4)
			( SortingColumn) ColumnName() string
			( SortingColumn) Descending() bool
				Returns true if the column will sort values in descending order.

			( SortingColumn) NullsFirst() bool
				Returns true if the column will put null values at the beginning.

			( SortingColumn) Path() []string
				Returns the path of the column in the row group schema, omitting the name
				of the root node.

		Implements (at least one exported)
			 SortingColumn : github.com/parquet-go/parquet-go.SortingColumn
		As Outputs Of (at least 4)
			func Ascending(column string) SortingColumn
			func Descending(column string) SortingColumn
			func NullsFirst(sortingColumn SortingColumn) SortingColumn
			func (*Schema).SortingColumns() []SortingColumn
		As Inputs Of (at least one exported)
			func NullsFirst(sortingColumn SortingColumn) SortingColumn

	 type StorageLayout (interface)

		Methods (total 5)
			( StorageLayout) GetCompressionInt32() int32
			( StorageLayout) GetEncodingInt32() int32
			( StorageLayout) GetNullable() bool
			( StorageLayout) GetRepeated() bool
			( StorageLayout) GetTypeInt32() int32
		As Outputs Of (at least one exported)
			func StorageLayoutWrapper(_ *schemav2pb.StorageLayout) StorageLayout


Package-Level Functions (total 33)

	 func Ascending(column string) SortingColumn
		Ascending constructs a SortingColumn value which dictates to sort by the column in ascending order.

	 func Concat(fields []parquet.Field, drg ...DynamicRowGroup) DynamicRowGroup
	 func DefinitionFromParquetFile(file *parquet.File) (*schemapb.Schema, error)
		DefinitionFromParquetFile converts a parquet file into a schemapb.Schema.

	 func Descending(column string) SortingColumn
		Descending constructs a SortingColumn value which dictates to sort by the column in descending order.

	 func FieldByName(fields []parquet.Field, name string) parquet.Field
	 func FindChildIndex(fields []parquet.Field, name string) int
	 func FindHashedColumn(col string, fields []arrow.Field) int
		findHashedColumn finds the index of the column in the given fields that have been prehashed.

	 func HashArray(arr arrow.Array) []uint64
	 func HashedColumnName(col string) string
	 func IsHashedColumn(col string) bool
	 func MergeDeduplicatedDynCols(dyn []string) []string
		MergeDeduplicatedDynCols is a light wrapper over sorting the deduplicated
		dynamic column names provided in dyn. It is extracted as a public method
		since this merging determines the order in which dynamic columns are stored
		and components from other packages sometimes need to figure out the physical
		sort order between dynamic columns.

	 func MergeDynamicColumnSets(sets []map[string][]string) map[string][]string
	 func NewDynamicRow(row parquet.Row, schema *parquet.Schema, dyncols map[string][]string, fields []parquet.Field) *DynamicRow
	 func NewDynamicRowGroupMergeAdapter(schema *parquet.Schema, sortingColumns []parquet.SortingColumn, mergedDynamicColumns map[string][]string, originalRowGroup parquet.RowGroup) *DynamicRowGroupMergeAdapter
		NewDynamicRowGroupMergeAdapter returns a *DynamicRowGroupMergeAdapter, which
		maps the columns of the original row group to the columns in the super-set
		schema provided. This allows row groups that have non-conflicting dynamic
		schemas to be merged into a single row group with a superset parquet schema.
		The provided schema must not conflict with the original row group's schema
		it must be strictly a superset, this property is not checked, it is assumed
		to be true for performance reasons.

	 func NewDynamicRows(rows []parquet.Row, schema *parquet.Schema, dynamicColumns map[string][]string, fields []parquet.Field) *DynamicRows
	 func NewDynamicRowSorter(schema *Schema, rows *DynamicRows) *DynamicRowSorter
	 func NewNilColumnChunk(typ parquet.Type, columnIndex, numValues int) *NilColumnChunk
		NewNilColumnChunk creates a new column chunk configured with the given type,
		column index and number of values in the page.

	 func NewSampleSchema() *Schema
	 func NewSerializedBuffer(f *parquet.File) (*SerializedBuffer, error)
	 func NullsFirst(sortingColumn SortingColumn) SortingColumn
		NullsFirst wraps the SortingColumn passed as argument so that it instructs
		the row group to place null values first in the column.

	 func ParquetSchemaFromV2Definition(def *schemav2pb.Schema) *parquet.Schema
	 func PrehashColumns(schema *Schema, r arrow.Record) arrow.Record
		prehashColumns prehashes the columns in the given record that have been marked as prehashed in the given schema.

	 func ReaderFromBytes(buf []byte) (*SerializedBuffer, error)
	 func RemoveHashedColumns(r arrow.Record) arrow.Record
		RemoveHashedColumns removes the hashed columns from the record.

	 func SchemaFromDefinition(msg proto.Message) (*Schema, error)
	 func SchemaFromParquetFile(file *parquet.File) (*Schema, error)
		SchemaFromParquetFile converts a parquet file into a dnyparquet.Schema.

	 func SortingColumnsFromDef(def *schemav2pb.Schema) ([]parquet.SortingColumn, error)
	 func StorageLayoutWrapper(_ *schemav2pb.StorageLayout) StorageLayout
	 func ToBuffer(s Samples, schema *Schema) (*Buffer, error)
	 func ToSnakeCase(str string) string
	 func ValuesForIndex(row parquet.Row, index int) []parquet.Value
	 func WithAlreadySorted() MergeOption
	 func WithDynamicCols(cols map[string][]string) MergeOption
Package-Level Variables (total 9)

	  var ErrMalformedDynamicColumns error
	  var ErrNoDynamicColumns error
	  var GenerateTestSamples func(n int) samples.Samples
	  var LabelColumn func(name string) *schemav1alpha2.Node
	  var NewNestedSampleSchema func(t testing.TB) proto.Message
	  var NewTestSamples func() samples.Samples
	  var PrehashedSampleDefinition func() *schemav1alpha1.Schema
	  var SampleDefinition func() *schemav1alpha1.Schema
	  var SampleDefinitionWithFloat func() *schemav1alpha1.Schema
Package-Level Constants (total 2)

	const ColumnIndexSize = 16
		The size of the column indicies in parquet files.

	const DynamicColumnsKey = "dynamic_columns"

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.