github.com/dolthub/go-mysql-server@v0.18.0/sql/plan/window_frame.og.go

// Code generated by optgen; DO NOT EDIT.

package plan

import (
	"github.com/dolthub/go-mysql-server/sql"
	agg "github.com/dolthub/go-mysql-server/sql/expression/function/aggregation"
)

type RowsUnboundedPrecedingToNPrecedingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsUnboundedPrecedingToNPrecedingFrame)(nil)

func NewRowsUnboundedPrecedingToNPrecedingFrame(endNPreceding sql.Expression) *RowsUnboundedPrecedingToNPrecedingFrame {
	return &RowsUnboundedPrecedingToNPrecedingFrame{
		windowFrameBase{
			isRows:             true,
			unboundedPreceding: true,
			endNPreceding:      endNPreceding,
		},
	}
}

func (f *RowsUnboundedPrecedingToNPrecedingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsUnboundedPrecedingToNPrecedingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsUnboundedPrecedingToNPrecedingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsUnboundedPrecedingToNPrecedingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsUnboundedPrecedingToNPrecedingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsUnboundedPrecedingToNPrecedingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsUnboundedPrecedingToNPrecedingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsUnboundedPrecedingToNPrecedingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsUnboundedPrecedingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsUnboundedPrecedingToNPrecedingFramer(f, w)
}

type RowsUnboundedPrecedingToCurrentRowFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsUnboundedPrecedingToCurrentRowFrame)(nil)

func NewRowsUnboundedPrecedingToCurrentRowFrame() *RowsUnboundedPrecedingToCurrentRowFrame {
	return &RowsUnboundedPrecedingToCurrentRowFrame{
		windowFrameBase{
			isRows:             true,
			unboundedPreceding: true,
			endCurrentRow:      true,
		},
	}
}

func (f *RowsUnboundedPrecedingToCurrentRowFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsUnboundedPrecedingToCurrentRowFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsUnboundedPrecedingToCurrentRowFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsUnboundedPrecedingToCurrentRowFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsUnboundedPrecedingToCurrentRowFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsUnboundedPrecedingToCurrentRowFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsUnboundedPrecedingToCurrentRowFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsUnboundedPrecedingToCurrentRowFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsUnboundedPrecedingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsUnboundedPrecedingToCurrentRowFramer(f, w)
}

type RowsUnboundedPrecedingToNFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsUnboundedPrecedingToNFollowingFrame)(nil)

func NewRowsUnboundedPrecedingToNFollowingFrame(endNFollowing sql.Expression) *RowsUnboundedPrecedingToNFollowingFrame {
	return &RowsUnboundedPrecedingToNFollowingFrame{
		windowFrameBase{
			isRows:             true,
			unboundedPreceding: true,
			endNFollowing:      endNFollowing,
		},
	}
}

func (f *RowsUnboundedPrecedingToNFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsUnboundedPrecedingToNFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsUnboundedPrecedingToNFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsUnboundedPrecedingToNFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsUnboundedPrecedingToNFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsUnboundedPrecedingToNFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsUnboundedPrecedingToNFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsUnboundedPrecedingToNFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsUnboundedPrecedingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsUnboundedPrecedingToNFollowingFramer(f, w)
}

type RowsUnboundedPrecedingToUnboundedFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsUnboundedPrecedingToUnboundedFollowingFrame)(nil)

func NewRowsUnboundedPrecedingToUnboundedFollowingFrame() *RowsUnboundedPrecedingToUnboundedFollowingFrame {
	return &RowsUnboundedPrecedingToUnboundedFollowingFrame{
		windowFrameBase{
			isRows:             true,
			unboundedPreceding: true,
			unboundedFollowing: true,
		},
	}
}

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsUnboundedPrecedingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsUnboundedPrecedingToUnboundedFollowingFramer(f, w)
}

type RowsNPrecedingToNPrecedingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsNPrecedingToNPrecedingFrame)(nil)

func NewRowsNPrecedingToNPrecedingFrame(startNPreceding sql.Expression, endNPreceding sql.Expression) *RowsNPrecedingToNPrecedingFrame {
	return &RowsNPrecedingToNPrecedingFrame{
		windowFrameBase{
			isRows:          true,
			startNPreceding: startNPreceding,
			endNPreceding:   endNPreceding,
		},
	}
}

func (f *RowsNPrecedingToNPrecedingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsNPrecedingToNPrecedingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsNPrecedingToNPrecedingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsNPrecedingToNPrecedingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsNPrecedingToNPrecedingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsNPrecedingToNPrecedingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsNPrecedingToNPrecedingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsNPrecedingToNPrecedingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsNPrecedingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsNPrecedingToNPrecedingFramer(f, w)
}

type RowsNPrecedingToCurrentRowFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsNPrecedingToCurrentRowFrame)(nil)

func NewRowsNPrecedingToCurrentRowFrame(startNPreceding sql.Expression) *RowsNPrecedingToCurrentRowFrame {
	return &RowsNPrecedingToCurrentRowFrame{
		windowFrameBase{
			isRows:          true,
			startNPreceding: startNPreceding,
			endCurrentRow:   true,
		},
	}
}

func (f *RowsNPrecedingToCurrentRowFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsNPrecedingToCurrentRowFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsNPrecedingToCurrentRowFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsNPrecedingToCurrentRowFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsNPrecedingToCurrentRowFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsNPrecedingToCurrentRowFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsNPrecedingToCurrentRowFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsNPrecedingToCurrentRowFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsNPrecedingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsNPrecedingToCurrentRowFramer(f, w)
}

type RowsNPrecedingToNFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsNPrecedingToNFollowingFrame)(nil)

func NewRowsNPrecedingToNFollowingFrame(startNPreceding sql.Expression, endNFollowing sql.Expression) *RowsNPrecedingToNFollowingFrame {
	return &RowsNPrecedingToNFollowingFrame{
		windowFrameBase{
			isRows:          true,
			startNPreceding: startNPreceding,
			endNFollowing:   endNFollowing,
		},
	}
}

func (f *RowsNPrecedingToNFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsNPrecedingToNFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsNPrecedingToNFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsNPrecedingToNFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsNPrecedingToNFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsNPrecedingToNFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsNPrecedingToNFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsNPrecedingToNFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsNPrecedingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsNPrecedingToNFollowingFramer(f, w)
}

type RowsNPrecedingToUnboundedFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsNPrecedingToUnboundedFollowingFrame)(nil)

func NewRowsNPrecedingToUnboundedFollowingFrame(startNPreceding sql.Expression) *RowsNPrecedingToUnboundedFollowingFrame {
	return &RowsNPrecedingToUnboundedFollowingFrame{
		windowFrameBase{
			isRows:             true,
			startNPreceding:    startNPreceding,
			unboundedFollowing: true,
		},
	}
}

func (f *RowsNPrecedingToUnboundedFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsNPrecedingToUnboundedFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsNPrecedingToUnboundedFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsNPrecedingToUnboundedFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsNPrecedingToUnboundedFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsNPrecedingToUnboundedFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsNPrecedingToUnboundedFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsNPrecedingToUnboundedFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsNPrecedingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsNPrecedingToUnboundedFollowingFramer(f, w)
}

type RowsCurrentRowToNPrecedingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsCurrentRowToNPrecedingFrame)(nil)

func NewRowsCurrentRowToNPrecedingFrame(endNPreceding sql.Expression) *RowsCurrentRowToNPrecedingFrame {
	return &RowsCurrentRowToNPrecedingFrame{
		windowFrameBase{
			isRows:          true,
			startCurrentRow: true,
			endNPreceding:   endNPreceding,
		},
	}
}

func (f *RowsCurrentRowToNPrecedingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsCurrentRowToNPrecedingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsCurrentRowToNPrecedingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsCurrentRowToNPrecedingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsCurrentRowToNPrecedingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsCurrentRowToNPrecedingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsCurrentRowToNPrecedingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsCurrentRowToNPrecedingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsCurrentRowToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsCurrentRowToNPrecedingFramer(f, w)
}

type RowsCurrentRowToCurrentRowFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsCurrentRowToCurrentRowFrame)(nil)

func NewRowsCurrentRowToCurrentRowFrame() *RowsCurrentRowToCurrentRowFrame {
	return &RowsCurrentRowToCurrentRowFrame{
		windowFrameBase{
			isRows:          true,
			startCurrentRow: true,
			endCurrentRow:   true,
		},
	}
}

func (f *RowsCurrentRowToCurrentRowFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsCurrentRowToCurrentRowFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsCurrentRowToCurrentRowFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsCurrentRowToCurrentRowFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsCurrentRowToCurrentRowFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsCurrentRowToCurrentRowFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsCurrentRowToCurrentRowFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsCurrentRowToCurrentRowFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsCurrentRowToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsCurrentRowToCurrentRowFramer(f, w)
}

type RowsCurrentRowToNFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsCurrentRowToNFollowingFrame)(nil)

func NewRowsCurrentRowToNFollowingFrame(endNFollowing sql.Expression) *RowsCurrentRowToNFollowingFrame {
	return &RowsCurrentRowToNFollowingFrame{
		windowFrameBase{
			isRows:          true,
			startCurrentRow: true,
			endNFollowing:   endNFollowing,
		},
	}
}

func (f *RowsCurrentRowToNFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsCurrentRowToNFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsCurrentRowToNFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsCurrentRowToNFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsCurrentRowToNFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsCurrentRowToNFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsCurrentRowToNFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsCurrentRowToNFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsCurrentRowToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsCurrentRowToNFollowingFramer(f, w)
}

type RowsCurrentRowToUnboundedFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsCurrentRowToUnboundedFollowingFrame)(nil)

func NewRowsCurrentRowToUnboundedFollowingFrame() *RowsCurrentRowToUnboundedFollowingFrame {
	return &RowsCurrentRowToUnboundedFollowingFrame{
		windowFrameBase{
			isRows:             true,
			startCurrentRow:    true,
			unboundedFollowing: true,
		},
	}
}

func (f *RowsCurrentRowToUnboundedFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsCurrentRowToUnboundedFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsCurrentRowToUnboundedFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsCurrentRowToUnboundedFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsCurrentRowToUnboundedFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsCurrentRowToUnboundedFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsCurrentRowToUnboundedFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsCurrentRowToUnboundedFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsCurrentRowToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsCurrentRowToUnboundedFollowingFramer(f, w)
}

type RowsNFollowingToNPrecedingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsNFollowingToNPrecedingFrame)(nil)

func NewRowsNFollowingToNPrecedingFrame(startNFollowing sql.Expression, endNPreceding sql.Expression) *RowsNFollowingToNPrecedingFrame {
	return &RowsNFollowingToNPrecedingFrame{
		windowFrameBase{
			isRows:          true,
			startNFollowing: startNFollowing,
			endNPreceding:   endNPreceding,
		},
	}
}

func (f *RowsNFollowingToNPrecedingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsNFollowingToNPrecedingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsNFollowingToNPrecedingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsNFollowingToNPrecedingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsNFollowingToNPrecedingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsNFollowingToNPrecedingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsNFollowingToNPrecedingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsNFollowingToNPrecedingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsNFollowingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsNFollowingToNPrecedingFramer(f, w)
}

type RowsNFollowingToCurrentRowFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsNFollowingToCurrentRowFrame)(nil)

func NewRowsNFollowingToCurrentRowFrame(startNFollowing sql.Expression) *RowsNFollowingToCurrentRowFrame {
	return &RowsNFollowingToCurrentRowFrame{
		windowFrameBase{
			isRows:          true,
			startNFollowing: startNFollowing,
			endCurrentRow:   true,
		},
	}
}

func (f *RowsNFollowingToCurrentRowFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsNFollowingToCurrentRowFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsNFollowingToCurrentRowFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsNFollowingToCurrentRowFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsNFollowingToCurrentRowFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsNFollowingToCurrentRowFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsNFollowingToCurrentRowFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsNFollowingToCurrentRowFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsNFollowingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsNFollowingToCurrentRowFramer(f, w)
}

type RowsNFollowingToNFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsNFollowingToNFollowingFrame)(nil)

func NewRowsNFollowingToNFollowingFrame(startNFollowing sql.Expression, endNFollowing sql.Expression) *RowsNFollowingToNFollowingFrame {
	return &RowsNFollowingToNFollowingFrame{
		windowFrameBase{
			isRows:          true,
			startNFollowing: startNFollowing,
			endNFollowing:   endNFollowing,
		},
	}
}

func (f *RowsNFollowingToNFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsNFollowingToNFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsNFollowingToNFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsNFollowingToNFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsNFollowingToNFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsNFollowingToNFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsNFollowingToNFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsNFollowingToNFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsNFollowingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsNFollowingToNFollowingFramer(f, w)
}

type RowsNFollowingToUnboundedFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RowsNFollowingToUnboundedFollowingFrame)(nil)

func NewRowsNFollowingToUnboundedFollowingFrame(startNFollowing sql.Expression) *RowsNFollowingToUnboundedFollowingFrame {
	return &RowsNFollowingToUnboundedFollowingFrame{
		windowFrameBase{
			isRows:             true,
			startNFollowing:    startNFollowing,
			unboundedFollowing: true,
		},
	}
}

func (f *RowsNFollowingToUnboundedFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RowsNFollowingToUnboundedFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RowsNFollowingToUnboundedFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RowsNFollowingToUnboundedFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RowsNFollowingToUnboundedFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RowsNFollowingToUnboundedFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RowsNFollowingToUnboundedFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RowsNFollowingToUnboundedFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RowsNFollowingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRowsNFollowingToUnboundedFollowingFramer(f, w)
}

type RangeUnboundedPrecedingToNPrecedingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeUnboundedPrecedingToNPrecedingFrame)(nil)

func NewRangeUnboundedPrecedingToNPrecedingFrame(endNPreceding sql.Expression) *RangeUnboundedPrecedingToNPrecedingFrame {
	return &RangeUnboundedPrecedingToNPrecedingFrame{
		windowFrameBase{
			isRange:            true,
			unboundedPreceding: true,
			endNPreceding:      endNPreceding,
		},
	}
}

func (f *RangeUnboundedPrecedingToNPrecedingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeUnboundedPrecedingToNPrecedingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeUnboundedPrecedingToNPrecedingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeUnboundedPrecedingToNPrecedingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeUnboundedPrecedingToNPrecedingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeUnboundedPrecedingToNPrecedingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeUnboundedPrecedingToNPrecedingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeUnboundedPrecedingToNPrecedingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeUnboundedPrecedingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeUnboundedPrecedingToNPrecedingFramer(f, w)
}

type RangeUnboundedPrecedingToCurrentRowFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeUnboundedPrecedingToCurrentRowFrame)(nil)

func NewRangeUnboundedPrecedingToCurrentRowFrame() *RangeUnboundedPrecedingToCurrentRowFrame {
	return &RangeUnboundedPrecedingToCurrentRowFrame{
		windowFrameBase{
			isRange:            true,
			unboundedPreceding: true,
			endCurrentRow:      true,
		},
	}
}

func (f *RangeUnboundedPrecedingToCurrentRowFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeUnboundedPrecedingToCurrentRowFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeUnboundedPrecedingToCurrentRowFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeUnboundedPrecedingToCurrentRowFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeUnboundedPrecedingToCurrentRowFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeUnboundedPrecedingToCurrentRowFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeUnboundedPrecedingToCurrentRowFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeUnboundedPrecedingToCurrentRowFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeUnboundedPrecedingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeUnboundedPrecedingToCurrentRowFramer(f, w)
}

type RangeUnboundedPrecedingToNFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeUnboundedPrecedingToNFollowingFrame)(nil)

func NewRangeUnboundedPrecedingToNFollowingFrame(endNFollowing sql.Expression) *RangeUnboundedPrecedingToNFollowingFrame {
	return &RangeUnboundedPrecedingToNFollowingFrame{
		windowFrameBase{
			isRange:            true,
			unboundedPreceding: true,
			endNFollowing:      endNFollowing,
		},
	}
}

func (f *RangeUnboundedPrecedingToNFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeUnboundedPrecedingToNFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeUnboundedPrecedingToNFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeUnboundedPrecedingToNFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeUnboundedPrecedingToNFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeUnboundedPrecedingToNFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeUnboundedPrecedingToNFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeUnboundedPrecedingToNFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeUnboundedPrecedingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeUnboundedPrecedingToNFollowingFramer(f, w)
}

type RangeUnboundedPrecedingToUnboundedFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeUnboundedPrecedingToUnboundedFollowingFrame)(nil)

func NewRangeUnboundedPrecedingToUnboundedFollowingFrame() *RangeUnboundedPrecedingToUnboundedFollowingFrame {
	return &RangeUnboundedPrecedingToUnboundedFollowingFrame{
		windowFrameBase{
			isRange:            true,
			unboundedPreceding: true,
			unboundedFollowing: true,
		},
	}
}

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeUnboundedPrecedingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeUnboundedPrecedingToUnboundedFollowingFramer(f, w)
}

type RangeNPrecedingToNPrecedingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeNPrecedingToNPrecedingFrame)(nil)

func NewRangeNPrecedingToNPrecedingFrame(startNPreceding sql.Expression, endNPreceding sql.Expression) *RangeNPrecedingToNPrecedingFrame {
	return &RangeNPrecedingToNPrecedingFrame{
		windowFrameBase{
			isRange:         true,
			startNPreceding: startNPreceding,
			endNPreceding:   endNPreceding,
		},
	}
}

func (f *RangeNPrecedingToNPrecedingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeNPrecedingToNPrecedingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeNPrecedingToNPrecedingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeNPrecedingToNPrecedingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeNPrecedingToNPrecedingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeNPrecedingToNPrecedingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeNPrecedingToNPrecedingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeNPrecedingToNPrecedingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeNPrecedingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeNPrecedingToNPrecedingFramer(f, w)
}

type RangeNPrecedingToCurrentRowFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeNPrecedingToCurrentRowFrame)(nil)

func NewRangeNPrecedingToCurrentRowFrame(startNPreceding sql.Expression) *RangeNPrecedingToCurrentRowFrame {
	return &RangeNPrecedingToCurrentRowFrame{
		windowFrameBase{
			isRange:         true,
			startNPreceding: startNPreceding,
			endCurrentRow:   true,
		},
	}
}

func (f *RangeNPrecedingToCurrentRowFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeNPrecedingToCurrentRowFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeNPrecedingToCurrentRowFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeNPrecedingToCurrentRowFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeNPrecedingToCurrentRowFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeNPrecedingToCurrentRowFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeNPrecedingToCurrentRowFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeNPrecedingToCurrentRowFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeNPrecedingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeNPrecedingToCurrentRowFramer(f, w)
}

type RangeNPrecedingToNFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeNPrecedingToNFollowingFrame)(nil)

func NewRangeNPrecedingToNFollowingFrame(startNPreceding sql.Expression, endNFollowing sql.Expression) *RangeNPrecedingToNFollowingFrame {
	return &RangeNPrecedingToNFollowingFrame{
		windowFrameBase{
			isRange:         true,
			startNPreceding: startNPreceding,
			endNFollowing:   endNFollowing,
		},
	}
}

func (f *RangeNPrecedingToNFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeNPrecedingToNFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeNPrecedingToNFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeNPrecedingToNFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeNPrecedingToNFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeNPrecedingToNFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeNPrecedingToNFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeNPrecedingToNFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeNPrecedingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeNPrecedingToNFollowingFramer(f, w)
}

type RangeNPrecedingToUnboundedFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeNPrecedingToUnboundedFollowingFrame)(nil)

func NewRangeNPrecedingToUnboundedFollowingFrame(startNPreceding sql.Expression) *RangeNPrecedingToUnboundedFollowingFrame {
	return &RangeNPrecedingToUnboundedFollowingFrame{
		windowFrameBase{
			isRange:            true,
			startNPreceding:    startNPreceding,
			unboundedFollowing: true,
		},
	}
}

func (f *RangeNPrecedingToUnboundedFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeNPrecedingToUnboundedFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeNPrecedingToUnboundedFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeNPrecedingToUnboundedFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeNPrecedingToUnboundedFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeNPrecedingToUnboundedFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeNPrecedingToUnboundedFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeNPrecedingToUnboundedFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeNPrecedingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeNPrecedingToUnboundedFollowingFramer(f, w)
}

type RangeCurrentRowToNPrecedingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeCurrentRowToNPrecedingFrame)(nil)

func NewRangeCurrentRowToNPrecedingFrame(endNPreceding sql.Expression) *RangeCurrentRowToNPrecedingFrame {
	return &RangeCurrentRowToNPrecedingFrame{
		windowFrameBase{
			isRange:         true,
			startCurrentRow: true,
			endNPreceding:   endNPreceding,
		},
	}
}

func (f *RangeCurrentRowToNPrecedingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeCurrentRowToNPrecedingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeCurrentRowToNPrecedingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeCurrentRowToNPrecedingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeCurrentRowToNPrecedingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeCurrentRowToNPrecedingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeCurrentRowToNPrecedingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeCurrentRowToNPrecedingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeCurrentRowToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeCurrentRowToNPrecedingFramer(f, w)
}

type RangeCurrentRowToCurrentRowFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeCurrentRowToCurrentRowFrame)(nil)

func NewRangeCurrentRowToCurrentRowFrame() *RangeCurrentRowToCurrentRowFrame {
	return &RangeCurrentRowToCurrentRowFrame{
		windowFrameBase{
			isRange:         true,
			startCurrentRow: true,
			endCurrentRow:   true,
		},
	}
}

func (f *RangeCurrentRowToCurrentRowFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeCurrentRowToCurrentRowFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeCurrentRowToCurrentRowFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeCurrentRowToCurrentRowFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeCurrentRowToCurrentRowFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeCurrentRowToCurrentRowFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeCurrentRowToCurrentRowFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeCurrentRowToCurrentRowFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeCurrentRowToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeCurrentRowToCurrentRowFramer(f, w)
}

type RangeCurrentRowToNFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeCurrentRowToNFollowingFrame)(nil)

func NewRangeCurrentRowToNFollowingFrame(endNFollowing sql.Expression) *RangeCurrentRowToNFollowingFrame {
	return &RangeCurrentRowToNFollowingFrame{
		windowFrameBase{
			isRange:         true,
			startCurrentRow: true,
			endNFollowing:   endNFollowing,
		},
	}
}

func (f *RangeCurrentRowToNFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeCurrentRowToNFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeCurrentRowToNFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeCurrentRowToNFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeCurrentRowToNFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeCurrentRowToNFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeCurrentRowToNFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeCurrentRowToNFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeCurrentRowToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeCurrentRowToNFollowingFramer(f, w)
}

type RangeCurrentRowToUnboundedFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeCurrentRowToUnboundedFollowingFrame)(nil)

func NewRangeCurrentRowToUnboundedFollowingFrame() *RangeCurrentRowToUnboundedFollowingFrame {
	return &RangeCurrentRowToUnboundedFollowingFrame{
		windowFrameBase{
			isRange:            true,
			startCurrentRow:    true,
			unboundedFollowing: true,
		},
	}
}

func (f *RangeCurrentRowToUnboundedFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeCurrentRowToUnboundedFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeCurrentRowToUnboundedFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeCurrentRowToUnboundedFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeCurrentRowToUnboundedFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeCurrentRowToUnboundedFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeCurrentRowToUnboundedFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeCurrentRowToUnboundedFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeCurrentRowToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeCurrentRowToUnboundedFollowingFramer(f, w)
}

type RangeNFollowingToNPrecedingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeNFollowingToNPrecedingFrame)(nil)

func NewRangeNFollowingToNPrecedingFrame(startNFollowing sql.Expression, endNPreceding sql.Expression) *RangeNFollowingToNPrecedingFrame {
	return &RangeNFollowingToNPrecedingFrame{
		windowFrameBase{
			isRange:         true,
			startNFollowing: startNFollowing,
			endNPreceding:   endNPreceding,
		},
	}
}

func (f *RangeNFollowingToNPrecedingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeNFollowingToNPrecedingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeNFollowingToNPrecedingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeNFollowingToNPrecedingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeNFollowingToNPrecedingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeNFollowingToNPrecedingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeNFollowingToNPrecedingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeNFollowingToNPrecedingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeNFollowingToNPrecedingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeNFollowingToNPrecedingFramer(f, w)
}

type RangeNFollowingToCurrentRowFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeNFollowingToCurrentRowFrame)(nil)

func NewRangeNFollowingToCurrentRowFrame(startNFollowing sql.Expression) *RangeNFollowingToCurrentRowFrame {
	return &RangeNFollowingToCurrentRowFrame{
		windowFrameBase{
			isRange:         true,
			startNFollowing: startNFollowing,
			endCurrentRow:   true,
		},
	}
}

func (f *RangeNFollowingToCurrentRowFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeNFollowingToCurrentRowFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeNFollowingToCurrentRowFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeNFollowingToCurrentRowFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeNFollowingToCurrentRowFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeNFollowingToCurrentRowFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeNFollowingToCurrentRowFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeNFollowingToCurrentRowFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeNFollowingToCurrentRowFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeNFollowingToCurrentRowFramer(f, w)
}

type RangeNFollowingToNFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeNFollowingToNFollowingFrame)(nil)

func NewRangeNFollowingToNFollowingFrame(startNFollowing sql.Expression, endNFollowing sql.Expression) *RangeNFollowingToNFollowingFrame {
	return &RangeNFollowingToNFollowingFrame{
		windowFrameBase{
			isRange:         true,
			startNFollowing: startNFollowing,
			endNFollowing:   endNFollowing,
		},
	}
}

func (f *RangeNFollowingToNFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeNFollowingToNFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeNFollowingToNFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeNFollowingToNFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeNFollowingToNFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeNFollowingToNFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeNFollowingToNFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeNFollowingToNFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeNFollowingToNFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeNFollowingToNFollowingFramer(f, w)
}

type RangeNFollowingToUnboundedFollowingFrame struct {
	windowFrameBase
}

var _ sql.WindowFrame = (*RangeNFollowingToUnboundedFollowingFrame)(nil)

func NewRangeNFollowingToUnboundedFollowingFrame(startNFollowing sql.Expression) *RangeNFollowingToUnboundedFollowingFrame {
	return &RangeNFollowingToUnboundedFollowingFrame{
		windowFrameBase{
			isRange:            true,
			startNFollowing:    startNFollowing,
			unboundedFollowing: true,
		},
	}
}

func (f *RangeNFollowingToUnboundedFollowingFrame) UnboundedPreceding() bool {
	return f.unboundedPreceding
}

func (f *RangeNFollowingToUnboundedFollowingFrame) StartNPreceding() sql.Expression {
	return f.startNPreceding
}

func (f *RangeNFollowingToUnboundedFollowingFrame) StartCurrentRow() bool {
	return f.startCurrentRow
}

func (f *RangeNFollowingToUnboundedFollowingFrame) StartNFollowing() sql.Expression {
	return f.startNFollowing
}

func (f *RangeNFollowingToUnboundedFollowingFrame) EndNPreceding() sql.Expression {
	return f.endNPreceding
}

func (f *RangeNFollowingToUnboundedFollowingFrame) EndCurrentRow() bool {
	return f.endCurrentRow
}

func (f *RangeNFollowingToUnboundedFollowingFrame) EndNFollowing() sql.Expression {
	return f.endNFollowing
}

func (f *RangeNFollowingToUnboundedFollowingFrame) UnboundedFollowing() bool {
	return f.unboundedFollowing
}

func (f *RangeNFollowingToUnboundedFollowingFrame) NewFramer(w *sql.WindowDefinition) (sql.WindowFramer, error) {
	return agg.NewRangeNFollowingToUnboundedFollowingFramer(f, w)
}