const (
    DistinctFuncType funcType
    AllFuncType
)

const ACTION = 57362

const ADD = 57363

const ALL = 57364

const ALTER = 57365

const ANALYSE = 57366

const ANALYZE = 57367

const AND = 57368

const ANNOTATE_TYPE = 57370

const ANY = 57369

const ARRAY = 57371

const AS = 57372

const ASC = 57373

const ASYMMETRIC = 57374

const AS_LA = 57664

const AT = 57375

const BACKUP = 57376

const BCONST = 57348

const BEGIN = 57377

const BETWEEN = 57378

const BIGINT = 57379

const BIGSERIAL = 57380

const BIT = 57381

const BLOB = 57382

const BOOL = 57383

const BOOLEAN = 57384

const BOTH = 57385

const BY = 57386

const BYTEA = 57387

const BYTES = 57388

const CANCEL = 57389

const CASCADE = 57390

const CASE = 57391

const CAST = 57392

const CHAR = 57393

const CHARACTER = 57394

const CHARACTERISTICS = 57395

const CHECK = 57396

const CLUSTER = 57397

const COALESCE = 57398

const COLLATE = 57399

const COLLATION = 57400

const COLUMN = 57401

const COLUMNS = 57402

const COMMIT = 57403

const COMMITTED = 57404

const CONCAT = 57405

const CONFLICT = 57406

const CONSTRAINT = 57407

const CONSTRAINTS = 57408

const COPY = 57409

const COVERING = 57410

const CREATE = 57411

const CROSS = 57412

const CUBE = 57413

const CURRENT = 57414

const CURRENT_CATALOG = 57415

const CURRENT_DATE = 57416

const CURRENT_ROLE = 57417

const CURRENT_TIME = 57418

const CURRENT_TIMESTAMP = 57419

const CURRENT_USER = 57420

const CYCLE = 57421

const DATA = 57422

const DATABASE = 57423

const DATABASES = 57424

const DATE = 57425

const DAY = 57426

const DEALLOCATE = 57430

const DEC = 57427

const DECIMAL = 57428

const DEFAULT = 57429

const DEFERRABLE = 57431

const DELETE = 57432

const DESC = 57433

const DISTINCT = 57434

const DO = 57435

const DOT_DOT = 57354

const DOUBLE = 57436

const DROP = 57437

const ELSE = 57438

const ENCODING = 57439

const END = 57440

const ERROR = 57361

const ESCAPE = 57441

const EXCEPT = 57442

const EXECUTE = 57444

const EXISTS = 57443

const EXPERIMENTAL_FINGERPRINTS = 57445

const EXPLAIN = 57446

const EXTRACT = 57447

const EXTRACT_DURATION = 57448

const FALSE = 57449

const FAMILY = 57450

const FCONST = 57350

const FETCH = 57451

const FILTER = 57452

const FIRST = 57453

const FLOAT = 57454

const FLOORDIV = 57455

const FOLLOWING = 57456

const FOR = 57457

const FORCE_INDEX = 57458

const FOREIGN = 57459

const FROM = 57460

const FULL = 57461

const GRANT = 57462

const GRANTS = 57463

const GREATER_EQUALS = 57356

const GREATEST = 57464

const GROUP = 57465

const GROUPING = 57466

const HAVING = 57467

const HELP = 57468

const HIGH = 57469

const HOUR = 57470

const ICONST = 57349

const IDENT = 57346

const IF = 57472

const IFNULL = 57473

const ILIKE = 57474

const IN = 57475

const INCREMENTAL = 57471

const INDEX = 57477

const INDEXES = 57478

const INITIALLY = 57479

const INNER = 57480

const INSERT = 57481

const INT = 57482

const INT2VECTOR = 57483

const INT64 = 57485

const INT8 = 57484

const INTEGER = 57486

const INTERLEAVE = 57476

const INTERSECT = 57487

const INTERVAL = 57488

const INTO = 57489

const IS = 57490

const ISOLATION = 57491

const InvalidColIdx = -1

const JOB = 57492

const JOIN = 57493

const KEY = 57494

const KEYS = 57495

const KV = 57496

const LATERAL = 57497

const LC_COLLATE = 57499

const LC_CTYPE = 57498

const LEADING = 57500

const LEAST = 57501

const LEFT = 57502

const LESS_EQUALS = 57355

const LEVEL = 57503

const LIKE = 57504

const LIMIT = 57505

const LOCAL = 57506

const LOCALTIME = 57507

const LOCALTIMESTAMP = 57508

const LOW = 57509

const LSHIFT = 57510

const MATCH = 57511

const MINUTE = 57512

const MONTH = 57513

const MaxInt = int(MaxUint >> 1)

const MaxUint = ^uint(0)

const NAME = 57515

const NAMES = 57516

const NAN = 57514

const NATURAL = 57517

const NEXT = 57518

const NO = 57519

const NORMAL = 57521

const NOT = 57522

const NOTHING = 57523

const NOT_EQUALS = 57357

const NOT_LA = 57662

const NOT_REGIMATCH = 57360

const NOT_REGMATCH = 57358

const NO_INDEX_JOIN = 57520

const NULL = 57524

const NULLIF = 57525

const NULLS = 57526

const NUMERIC = 57527

const OF = 57528

const OFF = 57529

const OFFSET = 57530

const OID = 57531

const ON = 57532

const ONLY = 57533

const OPTIONS = 57534

const OR = 57535

const ORDER = 57536

const ORDINALITY = 57537

const OUT = 57538

const OUTER = 57539

const OVER = 57540

const OVERLAPS = 57541

const OVERLAY = 57542

const PARENT = 57543

const PARTIAL = 57544

const PARTITION = 57545

const PASSWORD = 57546

const PAUSE = 57547

const PLACEHOLDER = 57351

const PLACING = 57548

const POSITION = 57549

const POSTFIXOP = 57665

const PRECEDING = 57550

const PRECISION = 57551

const PREPARE = 57552

const PRIMARY = 57553

const PRIORITY = 57554

const QUERIES = 57555

const QUERY = 57556

const RANGE = 57557

const READ = 57558

const REAL = 57559

const RECURSIVE = 57560

const REF = 57561

const REFERENCES = 57562

const REGCLASS = 57563

const REGIMATCH = 57359

const REGNAMESPACE = 57566

const REGPROC = 57564

const REGPROCEDURE = 57565

const REGTYPE = 57567

const RELEASE = 57570

const RENAME = 57568

const REPEATABLE = 57569

const RESET = 57571

const RESTORE = 57572

const RESTRICT = 57573

const RESUME = 57574

const RETURNING = 57575

const REVOKE = 57576

const RIGHT = 57577

const ROLLBACK = 57578

const ROLLUP = 57579

const ROW = 57580

const ROWS = 57581

const RSHIFT = 57582

const RestartSavepointName string = "COCKROACH_RESTART"

const SAVEPOINT = 57583

const SCATTER = 57584

const SCONST = 57347

const SEARCH = 57585

const SECOND = 57586

const SELECT = 57587

const SERIAL = 57588

const SERIALIZABLE = 57589

const SESSION = 57590

const SESSIONS = 57591

const SESSION_USER = 57592

const SET = 57593

const SETTING = 57594

const SETTINGS = 57595

const SHOW = 57596

const SIMILAR = 57597

const SIMPLE = 57598

const SMALLINT = 57599

const SMALLSERIAL = 57600

const SNAPSHOT = 57601

const SOME = 57602

const SPLIT = 57603

const SQL = 57604

const START = 57605

const STATUS = 57606

const STDIN = 57607

const STORING = 57610

const STRICT = 57608

const STRING = 57609

const SUBSTRING = 57611

const SYMMETRIC = 57612

const SYSTEM = 57613

const TABLE = 57614

const TABLES = 57615

const TEMPLATE = 57616

const TESTING_RANGES = 57617

const TESTING_RELOCATE = 57618

const TEXT = 57619

const THEN = 57620

const TIME = 57621

const TIMESTAMP = 57622

const TIMESTAMPTZ = 57623

const TO = 57624

const TRACE = 57626

const TRAILING = 57625

const TRANSACTION = 57627

const TREAT = 57628

const TRIM = 57629

const TRUE = 57630

const TRUNCATE = 57631

const TYPE = 57632

const TYPEANNOTATE = 57353

const TYPECAST = 57352

const (

    // TimestampOutputFormat is used to output all timestamps.
    TimestampOutputFormat = "2006-01-02 15:04:05.999999-07:00"
)

const UMINUS = 57666

const UNBOUNDED = 57633

const UNCOMMITTED = 57634

const UNION = 57635

const UNIQUE = 57636

const UNKNOWN = 57637

const UPDATE = 57638

const UPSERT = 57639

const USE = 57640

const USER = 57641

const USERS = 57642

const USING = 57643

const UUID = 57644

const VALID = 57645

const VALIDATE = 57646

const VALUE = 57647

const VALUES = 57648

const VARCHAR = 57649

const VARIADIC = 57650

const VARYING = 57652

const VIEW = 57651

const WHEN = 57653

const WHERE = 57654

const WINDOW = 57655

const WITH = 57656

const WITHIN = 57657

const WITHOUT = 57658

const WITH_LA = 57663

const WRITE = 57659

const YEAR = 57660

const ZONE = 57661

var (

    // DBoolTrue is a pointer to the DBool(true) value and can be used in
    // comparisons against Datum types.
    DBoolTrue = &constDBoolTrue
    // DBoolFalse is a pointer to the DBool(false) value and can be used in
    // comparisons against Datum types.
    DBoolFalse = &constDBoolFalse

    // DNull is the NULL Datum.
    DNull Datum = dNull{}

    // DZero is the zero-valued integer Datum.
    DZero = NewDInt(0)
)

var (
    // DecimalCtx is the default context for decimal operations. Any change
    // in the exponent limits must still guarantee a safe conversion to the
    // postegrs binary decimal format in the wire protocol, which uses an
    // int16. See pgwire/types.go.
    DecimalCtx = &apd.Context{
        Precision:   20,
        Rounding:    apd.RoundHalfUp,
        MaxExponent: 2000,
        MinExponent: -2000,
        Traps:       apd.DefaultTraps,
    }
    // ExactCtx is a decimal context with exact precision.
    ExactCtx = DecimalCtx.WithPrecision(0)
    // HighPrecisionCtx is a decimal context with high precision.
    HighPrecisionCtx = DecimalCtx.WithPrecision(2000)
    // RoundCtx is a decimal context with high precision and RoundHalfEven
    // rounding.
    RoundCtx = func() *apd.Context {
        ctx := *HighPrecisionCtx
        ctx.Rounding = apd.RoundHalfEven
        return &ctx
    }()
)

var (
    // TypeNull is the type of a DNull. Can be compared with ==.
    TypeNull Type = tNull{}
    // TypeBool is the type of a DBool. Can be compared with ==.
    TypeBool Type = tBool{}
    // TypeInt is the type of a DInt. Can be compared with ==.
    TypeInt Type = tInt{}
    // TypeFloat is the type of a DFloat. Can be compared with ==.
    TypeFloat Type = tFloat{}
    // TypeDecimal is the type of a DDecimal. Can be compared with ==.
    TypeDecimal Type = tDecimal{}
    // TypeString is the type of a DString. Can be compared with ==.
    TypeString Type = tString{}
    // TypeCollatedString is the type family of a DString. CANNOT be compared with
    // ==.
    TypeCollatedString Type = TCollatedString{}
    // TypeBytes is the type of a DBytes. Can be compared with ==.
    TypeBytes Type = tBytes{}
    // TypeDate is the type of a DDate. Can be compared with ==.
    TypeDate Type = tDate{}
    // TypeTimestamp is the type of a DTimestamp. Can be compared with ==.
    TypeTimestamp Type = tTimestamp{}
    // TypeTimestampTZ is the type of a DTimestampTZ. Can be compared with ==.
    TypeTimestampTZ Type = tTimestampTZ{}
    // TypeInterval is the type of a DInterval. Can be compared with ==.
    TypeInterval Type = tInterval{}
    // TypeUUID is the type of a DUuid. Can be compared with ==.
    TypeUUID Type = tUUID{}
    // TypeTuple is the type family of a DTuple. CANNOT be compared with ==.
    TypeTuple Type = TTuple(nil)
    // TypeTable is the type family of a DTable. CANNOT be compared with ==.
    TypeTable Type = TTable{}
    // TypePlaceholder is the type family of a placeholder. CANNOT be compared
    // with ==.
    TypePlaceholder Type = TPlaceholder{}
    // TypeStringArray is the type family of a DArray containing strings. Can be
    // compared with ==.
    TypeStringArray Type = TArray{TypeString}
    // TypeIntArray is the type family of a DArray containing ints. Can be
    // compared with ==.
    TypeIntArray Type = TArray{TypeInt}
    // TypeAnyArray is the type of a DArray with a wildcard parameterized type.
    // Can be compared with ==.
    TypeAnyArray Type = TArray{TypeAny}
    // TypeAny can be any type. Can be compared with ==.
    TypeAny Type = tAny{}

    // TypeOid is the type of an OID. Can be compared with ==.
    TypeOid = tOid{oid.T_oid}
    // TypeRegClass is the type of an regclass OID variant. Can be compared with ==.
    TypeRegClass = tOid{oid.T_regclass}
    // TypeRegNamespace is the type of an regnamespace OID variant. Can be compared with ==.
    TypeRegNamespace = tOid{oid.T_regnamespace}
    // TypeRegProc is the type of an regproc OID variant. Can be compared with ==.
    TypeRegProc = tOid{oid.T_regproc}
    // TypeRegProcedure is the type of an regprocedure OID variant. Can be compared with ==.
    TypeRegProcedure = tOid{oid.T_regprocedure}
    // TypeRegType is the type of an regtype OID variant. Can be compared with ==.
    TypeRegType = tOid{oid.T_regtype}

    // TypeName is a type-alias for TypeString with a different OID. Can be
    // compared with ==.
    TypeName = wrapTypeWithOid(TypeString, oid.T_name)
    // TypeIntVector is a type-alias for a TypeIntArray with a different OID. Can
    // be compared with ==.
    TypeIntVector = wrapTypeWithOid(TypeIntArray, oid.T_int2vector)
    // TypeNameArray is the type family of a DArray containing the Name alias type.
    // Can be compared with ==.
    TypeNameArray Type = TArray{TypeName}

    // TypesAnyNonArray contains all non-array types.
    TypesAnyNonArray = []Type{
        TypeBool,
        TypeInt,
        TypeFloat,
        TypeDecimal,
        TypeString,
        TypeBytes,
        TypeDate,
        TypeTimestamp,
        TypeTimestampTZ,
        TypeInterval,
        TypeUUID,
        TypeOid,
    }
)

var AbsentReturningClause = &NoReturningClause{}

var Aggregates = map[string][]Builtin{
    "array_agg": {
        makeAggBuiltinWithReturnType(
            TypeAny,
            func(args []TypedExpr) Type {
                if len(args) == 0 {
                    return unknownReturnType
                }
                return TArray{args[0].ResolvedType()}
            },
            newArrayAggregate,
            "Aggregates the selected values into an array.",
        ),
    },

    "avg": {
        makeAggBuiltin(TypeInt, TypeDecimal, newIntAvgAggregate,
            "Calculates the average of the selected values."),
        makeAggBuiltin(TypeFloat, TypeFloat, newFloatAvgAggregate,
            "Calculates the average of the selected values."),
        makeAggBuiltin(TypeDecimal, TypeDecimal, newDecimalAvgAggregate,
            "Calculates the average of the selected values."),
    },

    "bool_and": {
        makeAggBuiltin(TypeBool, TypeBool, newBoolAndAggregate,
            "Calculates the boolean value of `AND`ing all selected values."),
    },

    "bool_or": {
        makeAggBuiltin(TypeBool, TypeBool, newBoolOrAggregate,
            "Calculates the boolean value of `OR`ing all selected values."),
    },

    "concat_agg": {

        makeAggBuiltin(TypeString, TypeString, newStringConcatAggregate,
            "Concatenates all selected values."),
        makeAggBuiltin(TypeBytes, TypeBytes, newBytesConcatAggregate,
            "Concatenates all selected values."),
    },

    "count": {
        makeAggBuiltin(TypeAny, TypeInt, newCountAggregate,
            "Calculates the number of selected elements."),
    },

    "count_rows": {
        {
            impure:        true,
            class:         AggregateClass,
            Types:         ArgTypes{},
            ReturnType:    fixedReturnType(TypeInt),
            AggregateFunc: newCountRowsAggregate,
            WindowFunc: func(params []Type, evalCtx *EvalContext) WindowFunc {
                return newAggregateWindow(newCountRowsAggregate(params, evalCtx))
            },
            Info: "Calculates the number of rows.",
        },
    },

    "max": collectBuiltins(func(t Type) Builtin {
        return makeAggBuiltin(t, t, newMaxAggregate,
            "Identifies the maximum selected value.")
    }, TypesAnyNonArray...),
    "min": collectBuiltins(func(t Type) Builtin {
        return makeAggBuiltin(t, t, newMinAggregate,
            "Identifies the minimum selected value.")
    }, TypesAnyNonArray...),

    "sum_int": {
        makeAggBuiltin(TypeInt, TypeInt, newSmallIntSumAggregate,
            "Calculates the sum of the selected values."),
    },

    "sum": {
        makeAggBuiltin(TypeInt, TypeDecimal, newIntSumAggregate,
            "Calculates the sum of the selected values."),
        makeAggBuiltin(TypeFloat, TypeFloat, newFloatSumAggregate,
            "Calculates the sum of the selected values."),
        makeAggBuiltin(TypeDecimal, TypeDecimal, newDecimalSumAggregate,
            "Calculates the sum of the selected values."),
        makeAggBuiltin(TypeInterval, TypeInterval, newIntervalSumAggregate,
            "Calculates the sum of the selected values."),
    },

    "variance": {
        makeAggBuiltin(TypeInt, TypeDecimal, newIntVarianceAggregate,
            "Calculates the variance of the selected values."),
        makeAggBuiltin(TypeDecimal, TypeDecimal, newDecimalVarianceAggregate,
            "Calculates the variance of the selected values."),
        makeAggBuiltin(TypeFloat, TypeFloat, newFloatVarianceAggregate,
            "Calculates the variance of the selected values."),
    },

    "stddev": {
        makeAggBuiltin(TypeInt, TypeDecimal, newIntStdDevAggregate,
            "Calculates the standard deviation of the selected values."),
        makeAggBuiltin(TypeDecimal, TypeDecimal, newDecimalStdDevAggregate,
            "Calculates the standard deviation of the selected values."),
        makeAggBuiltin(TypeFloat, TypeFloat, newFloatStdDevAggregate,
            "Calculates the standard deviation of the selected values."),
    },

    "xor_agg": {
        makeAggBuiltin(TypeBytes, TypeBytes, newBytesXorAggregate,
            "Calculates the bitwise XOR of the selected values."),
        makeAggBuiltin(TypeInt, TypeInt, newIntXorAggregate,
            "Calculates the bitwise XOR of the selected values."),
    },
}

var BinOps = map[BinaryOperator]binOpOverload{
    Bitand: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDInt(MustBeDInt(left) & MustBeDInt(right)), nil
            },
        },
    },

    Bitor: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDInt(MustBeDInt(left) | MustBeDInt(right)), nil
            },
        },
    },

    Bitxor: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDInt(MustBeDInt(left) ^ MustBeDInt(right)), nil
            },
        },
    },

    Plus: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                a, b := MustBeDInt(left), MustBeDInt(right)
                if b > 0 && a > math.MaxInt64-b {
                    return nil, errIntOutOfRange
                }
                if b < 0 && a < math.MinInt64-b {
                    return nil, errIntOutOfRange
                }
                return NewDInt(a + b), nil
            },
        },
        BinOp{
            LeftType:   TypeFloat,
            RightType:  TypeFloat,
            ReturnType: TypeFloat,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDFloat(*left.(*DFloat) + *right.(*DFloat)), nil
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                _, err := ExactCtx.Add(&dd.Decimal, l, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeInt,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := MustBeDInt(right)
                dd := &DDecimal{}
                dd.SetCoefficient(int64(r))
                _, err := ExactCtx.Add(&dd.Decimal, l, &dd.Decimal)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := MustBeDInt(left)
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                dd.SetCoefficient(int64(l))
                _, err := ExactCtx.Add(&dd.Decimal, &dd.Decimal, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeDate,
            RightType:  TypeInt,
            ReturnType: TypeDate,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDDate(*left.(*DDate) + DDate(MustBeDInt(right))), nil
            },
        },
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeDate,
            ReturnType: TypeDate,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDDate(DDate(MustBeDInt(left)) + *right.(*DDate)), nil
            },
        },
        BinOp{
            LeftType:   TypeTimestamp,
            RightType:  TypeInterval,
            ReturnType: TypeTimestamp,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return MakeDTimestamp(duration.Add(left.(*DTimestamp).Time, right.(*DInterval).Duration), time.Microsecond), nil
            },
        },
        BinOp{
            LeftType:   TypeInterval,
            RightType:  TypeTimestamp,
            ReturnType: TypeTimestamp,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return MakeDTimestamp(duration.Add(right.(*DTimestamp).Time, left.(*DInterval).Duration), time.Microsecond), nil
            },
        },
        BinOp{
            LeftType:   TypeTimestampTZ,
            RightType:  TypeInterval,
            ReturnType: TypeTimestampTZ,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                t := duration.Add(left.(*DTimestampTZ).Time, right.(*DInterval).Duration)
                return MakeDTimestampTZ(t, time.Microsecond), nil
            },
        },
        BinOp{
            LeftType:   TypeInterval,
            RightType:  TypeTimestampTZ,
            ReturnType: TypeTimestampTZ,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                t := duration.Add(right.(*DTimestampTZ).Time, left.(*DInterval).Duration)
                return MakeDTimestampTZ(t, time.Microsecond), nil
            },
        },
        BinOp{
            LeftType:   TypeInterval,
            RightType:  TypeInterval,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return &DInterval{Duration: left.(*DInterval).Duration.Add(right.(*DInterval).Duration)}, nil
            },
        },
        BinOp{
            LeftType:   TypeDate,
            RightType:  TypeInterval,
            ReturnType: TypeTimestampTZ,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                leftTZ := MakeDTimestampTZFromDate(ctx.GetLocation(), left.(*DDate))
                t := duration.Add(leftTZ.Time, right.(*DInterval).Duration)
                return MakeDTimestampTZ(t, time.Microsecond), nil
            },
        },
        BinOp{
            LeftType:   TypeInterval,
            RightType:  TypeDate,
            ReturnType: TypeTimestampTZ,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                rightTZ := MakeDTimestampTZFromDate(ctx.GetLocation(), right.(*DDate))
                t := duration.Add(rightTZ.Time, left.(*DInterval).Duration)
                return MakeDTimestampTZ(t, time.Microsecond), nil
            },
        },
    },

    Minus: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                a, b := MustBeDInt(left), MustBeDInt(right)
                if b < 0 && a > math.MaxInt64+b {
                    return nil, errIntOutOfRange
                }
                if b > 0 && a < math.MinInt64+b {
                    return nil, errIntOutOfRange
                }
                return NewDInt(a - b), nil
            },
        },
        BinOp{
            LeftType:   TypeFloat,
            RightType:  TypeFloat,
            ReturnType: TypeFloat,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDFloat(*left.(*DFloat) - *right.(*DFloat)), nil
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                _, err := ExactCtx.Sub(&dd.Decimal, l, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeInt,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := MustBeDInt(right)
                dd := &DDecimal{}
                dd.SetCoefficient(int64(r))
                _, err := ExactCtx.Sub(&dd.Decimal, l, &dd.Decimal)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := MustBeDInt(left)
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                dd.SetCoefficient(int64(l))
                _, err := ExactCtx.Sub(&dd.Decimal, &dd.Decimal, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeDate,
            RightType:  TypeInt,
            ReturnType: TypeDate,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDDate(*left.(*DDate) - DDate(MustBeDInt(right))), nil
            },
        },
        BinOp{
            LeftType:   TypeDate,
            RightType:  TypeDate,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDInt(DInt(*left.(*DDate) - *right.(*DDate))), nil
            },
        },
        BinOp{
            LeftType:   TypeTimestamp,
            RightType:  TypeTimestamp,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                nanos := left.(*DTimestamp).Sub(right.(*DTimestamp).Time).Nanoseconds()
                return &DInterval{Duration: duration.Duration{Nanos: nanos}}, nil
            },
        },
        BinOp{
            LeftType:   TypeTimestampTZ,
            RightType:  TypeTimestampTZ,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                nanos := left.(*DTimestampTZ).Sub(right.(*DTimestampTZ).Time).Nanoseconds()
                return &DInterval{Duration: duration.Duration{Nanos: nanos}}, nil
            },
        },
        BinOp{
            LeftType:   TypeTimestamp,
            RightType:  TypeTimestampTZ,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                nanos := left.(*DTimestamp).Sub(right.(*DTimestampTZ).Time).Nanoseconds()
                return &DInterval{Duration: duration.Duration{Nanos: nanos}}, nil
            },
        },
        BinOp{
            LeftType:   TypeTimestampTZ,
            RightType:  TypeTimestamp,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                nanos := left.(*DTimestampTZ).Sub(right.(*DTimestamp).Time).Nanoseconds()
                return &DInterval{Duration: duration.Duration{Nanos: nanos}}, nil
            },
        },
        BinOp{
            LeftType:   TypeTimestamp,
            RightType:  TypeInterval,
            ReturnType: TypeTimestamp,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return MakeDTimestamp(duration.Add(left.(*DTimestamp).Time, right.(*DInterval).Duration.Mul(-1)), time.Microsecond), nil
            },
        },
        BinOp{
            LeftType:   TypeTimestampTZ,
            RightType:  TypeInterval,
            ReturnType: TypeTimestampTZ,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                t := duration.Add(left.(*DTimestampTZ).Time, right.(*DInterval).Duration.Mul(-1))
                return MakeDTimestampTZ(t, time.Microsecond), nil
            },
        },
        BinOp{
            LeftType:   TypeDate,
            RightType:  TypeInterval,
            ReturnType: TypeTimestampTZ,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                leftTZ := MakeDTimestampTZFromDate(ctx.GetLocation(), left.(*DDate))
                t := duration.Add(leftTZ.Time, right.(*DInterval).Duration.Mul(-1))
                return MakeDTimestampTZ(t, time.Microsecond), nil
            },
        },
        BinOp{
            LeftType:   TypeInterval,
            RightType:  TypeInterval,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return &DInterval{Duration: left.(*DInterval).Duration.Sub(right.(*DInterval).Duration)}, nil
            },
        },
    },

    Mult: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {

                a, b := MustBeDInt(left), MustBeDInt(right)
                c := a * b
                if a == 0 || b == 0 || a == 1 || b == 1 {

                } else if a == math.MinInt64 || b == math.MinInt64 {

                    return nil, errIntOutOfRange
                } else if c/b != a {
                    return nil, errIntOutOfRange
                }
                return NewDInt(c), nil
            },
        },
        BinOp{
            LeftType:   TypeFloat,
            RightType:  TypeFloat,
            ReturnType: TypeFloat,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDFloat(*left.(*DFloat) * *right.(*DFloat)), nil
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                _, err := ExactCtx.Mul(&dd.Decimal, l, r)
                return dd, err
            },
        },

        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeInt,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := MustBeDInt(right)
                dd := &DDecimal{}
                dd.SetCoefficient(int64(r))
                _, err := ExactCtx.Mul(&dd.Decimal, l, &dd.Decimal)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := MustBeDInt(left)
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                dd.SetCoefficient(int64(l))
                _, err := ExactCtx.Mul(&dd.Decimal, &dd.Decimal, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInterval,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return &DInterval{Duration: right.(*DInterval).Duration.Mul(int64(MustBeDInt(left)))}, nil
            },
        },
        BinOp{
            LeftType:   TypeInterval,
            RightType:  TypeInt,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return &DInterval{Duration: left.(*DInterval).Duration.Mul(int64(MustBeDInt(right)))}, nil
            },
        },
        BinOp{
            LeftType:   TypeInterval,
            RightType:  TypeFloat,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                r := float64(*right.(*DFloat))
                return &DInterval{Duration: left.(*DInterval).Duration.MulFloat(r)}, nil
            },
        },
    },

    Div: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeDecimal,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                rInt := MustBeDInt(right)
                div := ctx.getTmpDec().SetCoefficient(int64(rInt)).SetExponent(0)
                dd := &DDecimal{}
                dd.SetCoefficient(int64(MustBeDInt(left)))
                _, err := DecimalCtx.Quo(&dd.Decimal, &dd.Decimal, div)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeFloat,
            RightType:  TypeFloat,
            ReturnType: TypeFloat,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDFloat(*left.(*DFloat) / *right.(*DFloat)), nil
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                _, err := DecimalCtx.Quo(&dd.Decimal, l, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeInt,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := MustBeDInt(right)
                dd := &DDecimal{}
                dd.SetCoefficient(int64(r))
                _, err := DecimalCtx.Quo(&dd.Decimal, l, &dd.Decimal)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := MustBeDInt(left)
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                dd.SetCoefficient(int64(l))
                _, err := DecimalCtx.Quo(&dd.Decimal, &dd.Decimal, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeInterval,
            RightType:  TypeInt,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                rInt := MustBeDInt(right)
                if rInt == 0 {
                    return nil, errDivByZero
                }
                return &DInterval{Duration: left.(*DInterval).Duration.Div(int64(rInt))}, nil
            },
        },
        BinOp{
            LeftType:   TypeInterval,
            RightType:  TypeFloat,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                r := float64(*right.(*DFloat))
                if r == 0.0 {
                    return nil, errDivByZero
                }
                return &DInterval{Duration: left.(*DInterval).Duration.DivFloat(r)}, nil
            },
        },
    },

    FloorDiv: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                rInt := MustBeDInt(right)
                if rInt == 0 {
                    return nil, errDivByZero
                }
                return NewDInt(MustBeDInt(left) / rInt), nil
            },
        },
        BinOp{
            LeftType:   TypeFloat,
            RightType:  TypeFloat,
            ReturnType: TypeFloat,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := float64(*left.(*DFloat))
                r := float64(*right.(*DFloat))
                return NewDFloat(DFloat(math.Trunc(l / r))), nil
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                _, err := HighPrecisionCtx.QuoInteger(&dd.Decimal, l, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeInt,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := MustBeDInt(right)
                if r == 0 {
                    return nil, errDivByZero
                }
                dd := &DDecimal{}
                dd.SetCoefficient(int64(r))
                _, err := HighPrecisionCtx.QuoInteger(&dd.Decimal, l, &dd.Decimal)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := MustBeDInt(left)
                r := &right.(*DDecimal).Decimal
                if r.Sign() == 0 {
                    return nil, errDivByZero
                }
                dd := &DDecimal{}
                dd.SetCoefficient(int64(l))
                _, err := HighPrecisionCtx.QuoInteger(&dd.Decimal, &dd.Decimal, r)
                return dd, err
            },
        },
    },

    Mod: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                r := MustBeDInt(right)
                if r == 0 {
                    return nil, errZeroModulus
                }
                return NewDInt(MustBeDInt(left) % r), nil
            },
        },
        BinOp{
            LeftType:   TypeFloat,
            RightType:  TypeFloat,
            ReturnType: TypeFloat,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDFloat(DFloat(math.Mod(float64(*left.(*DFloat)), float64(*right.(*DFloat))))), nil
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                _, err := HighPrecisionCtx.Rem(&dd.Decimal, l, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeInt,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := MustBeDInt(right)
                dd := &DDecimal{}
                dd.SetCoefficient(int64(r))
                _, err := HighPrecisionCtx.Rem(&dd.Decimal, l, &dd.Decimal)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := MustBeDInt(left)
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                dd.SetCoefficient(int64(l))
                _, err := HighPrecisionCtx.Rem(&dd.Decimal, &dd.Decimal, r)
                return dd, err
            },
        },
    },

    Concat: {
        BinOp{
            LeftType:   TypeString,
            RightType:  TypeString,
            ReturnType: TypeString,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDString(string(MustBeDString(left) + MustBeDString(right))), nil
            },
        },
        BinOp{
            LeftType:   TypeBytes,
            RightType:  TypeBytes,
            ReturnType: TypeBytes,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDBytes(*left.(*DBytes) + *right.(*DBytes)), nil
            },
        },
    },

    LShift: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDInt(MustBeDInt(left) << uint(MustBeDInt(right))), nil
            },
        },
    },

    RShift: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                return NewDInt(MustBeDInt(left) >> uint(MustBeDInt(right))), nil
            },
        },
    },

    Pow: {
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeInt,
            ReturnType: TypeInt,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                return intPow(MustBeDInt(left), MustBeDInt(right))
            },
        },
        BinOp{
            LeftType:   TypeFloat,
            RightType:  TypeFloat,
            ReturnType: TypeFloat,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                f := math.Pow(float64(*left.(*DFloat)), float64(*right.(*DFloat)))
                return NewDFloat(DFloat(f)), nil
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                _, err := DecimalCtx.Pow(&dd.Decimal, l, r)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeDecimal,
            RightType:  TypeInt,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := &left.(*DDecimal).Decimal
                r := MustBeDInt(right)
                dd := &DDecimal{}
                dd.SetCoefficient(int64(r))
                _, err := DecimalCtx.Pow(&dd.Decimal, l, &dd.Decimal)
                return dd, err
            },
        },
        BinOp{
            LeftType:   TypeInt,
            RightType:  TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
                l := MustBeDInt(left)
                r := &right.(*DDecimal).Decimal
                dd := &DDecimal{}
                dd.SetCoefficient(int64(l))
                _, err := DecimalCtx.Pow(&dd.Decimal, &dd.Decimal, r)
                return dd, err
            },
        },
    },
}

var Builtins = map[string][]Builtin{

    "length": {
        stringBuiltin1(func(_ *EvalContext, s string) (Datum, error) {
            return NewDInt(DInt(utf8.RuneCountInString(s))), nil
        }, TypeInt, "Calculates the number of characters in `val`."),
        bytesBuiltin1(func(_ *EvalContext, s string) (Datum, error) {
            return NewDInt(DInt(len(s))), nil
        }, TypeInt, "Calculates the number of bytes in `val`."),
    },

    "octet_length": {
        stringBuiltin1(func(_ *EvalContext, s string) (Datum, error) {
            return NewDInt(DInt(len(s))), nil
        }, TypeInt, "Calculates the number of bytes used to represent `val`."),
        bytesBuiltin1(func(_ *EvalContext, s string) (Datum, error) {
            return NewDInt(DInt(len(s))), nil
        }, TypeInt, "Calculates the number of bytes in `val`."),
    },

    "lower": {stringBuiltin1(func(evalCtx *EvalContext, s string) (Datum, error) {
        if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(len(s))); err != nil {
            return nil, err
        }
        return NewDString(strings.ToLower(s)), nil
    }, TypeString, "Converts all characters in `val`to their lower-case equivalents.")},

    "upper": {stringBuiltin1(func(evalCtx *EvalContext, s string) (Datum, error) {
        if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(len(s))); err != nil {
            return nil, err
        }
        return NewDString(strings.ToUpper(s)), nil
    }, TypeString, "Converts all characters in `val`to their to their upper-case equivalents.")},

    "substr":    substringImpls,
    "substring": substringImpls,

    "concat": {
        Builtin{
            Types:      VariadicType{TypeString},
            ReturnType: fixedReturnType(TypeString),
            fn: func(evalCtx *EvalContext, args Datums) (Datum, error) {
                var buffer bytes.Buffer
                for _, d := range args {
                    if d == DNull {
                        continue
                    }
                    nextLength := len(string(MustBeDString(d)))
                    if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(nextLength)); err != nil {
                        return nil, err
                    }
                    buffer.WriteString(string(MustBeDString(d)))
                }
                return NewDString(buffer.String()), nil
            },
            Info: "Concatenates a comma-separated list of strings.",
        },
    },

    "concat_ws": {
        Builtin{
            Types:      VariadicType{TypeString},
            ReturnType: fixedReturnType(TypeString),
            fn: func(evalCtx *EvalContext, args Datums) (Datum, error) {
                if len(args) == 0 {
                    return nil, errInsufficientArgs
                }
                if args[0] == DNull {
                    return DNull, nil
                }
                sep := string(MustBeDString(args[0]))
                var buf bytes.Buffer
                prefix := ""
                for _, d := range args[1:] {
                    if d == DNull {
                        continue
                    }
                    nextLength := len(prefix) + len(string(MustBeDString(d)))
                    if err := evalCtx.ActiveMemAcc.Grow(
                        evalCtx.Ctx(), int64(nextLength)); err != nil {
                        return nil, err
                    }

                    buf.WriteString(prefix)
                    prefix = sep
                    buf.WriteString(string(MustBeDString(d)))
                }
                return NewDString(buf.String()), nil
            },
            Info: "Uses the first argument as a separator between the concatenation of the " +
                "subsequent arguments. <br/><br/>For example `concat_ws('!','wow','great')` " +
                "returns `wow!great`.",
        },
    },

    "to_uuid": {
        Builtin{
            Types:      ArgTypes{{"val", TypeString}},
            ReturnType: fixedReturnType(TypeBytes),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                s := string(MustBeDString(args[0]))
                uv, err := uuid.FromString(s)
                if err != nil {
                    return nil, err
                }
                return NewDBytes(DBytes(uv.GetBytes())), nil
            },
            Info: "Converts the character string representation of a UUID to its byte string " +
                "representation.",
        },
    },

    "from_uuid": {
        Builtin{
            Types:      ArgTypes{{"val", TypeBytes}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                b := []byte(*args[0].(*DBytes))
                uv, err := uuid.FromBytes(b)
                if err != nil {
                    return nil, err
                }
                return NewDString(uv.String()), nil
            },
            Info: "Converts the byte string representation of a UUID to its character string " +
                "representation.",
        },
    },

    "from_ip": {
        Builtin{
            Types:      ArgTypes{{"val", TypeBytes}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                ipstr := args[0].(*DBytes)
                nboip := net.IP(*ipstr)
                sv := nboip.String()

                if sv == "<nil>" {
                    return nil, errZeroIP
                }
                return NewDString(sv), nil
            },
            Info: "Converts the byte string representation of an IP to its character string " +
                "representation.",
        },
    },

    "to_ip": {
        Builtin{
            Types:      ArgTypes{{"val", TypeString}},
            ReturnType: fixedReturnType(TypeBytes),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                ipdstr := MustBeDString(args[0])
                ip := net.ParseIP(string(ipdstr))

                if ip == nil {
                    return nil, fmt.Errorf("invalid IP format: %s", ipdstr.String())
                }
                return NewDBytes(DBytes(ip)), nil
            },
            Info: "Converts the character string representation of an IP to its byte string " +
                "representation.",
        },
    },

    "split_part": {
        Builtin{
            Types: ArgTypes{
                {"input", TypeString},
                {"delimiter", TypeString},
                {"return_index_pos", TypeInt},
            },
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                text := string(MustBeDString(args[0]))
                sep := string(MustBeDString(args[1]))
                field := int(MustBeDInt(args[2]))

                if field <= 0 {
                    return nil, fmt.Errorf("field position %d must be greater than zero", field)
                }

                splits := strings.Split(text, sep)
                if field > len(splits) {
                    return NewDString(""), nil
                }
                return NewDString(splits[field-1]), nil
            },
            Info: "Splits `input` on `delimiter` and return the value in the `return_index_pos`  " +
                "position (starting at 1). <br/><br/>For example, `split_part('123.456.789.0','.',3)`" +
                "returns `789`.",
        },
    },

    "repeat": {
        Builtin{
            Types:            ArgTypes{{"input", TypeString}, {"repeat_counter", TypeInt}},
            distsqlBlacklist: true,
            ReturnType:       fixedReturnType(TypeString),
            fn: func(evalCtx *EvalContext, args Datums) (_ Datum, err error) {
                s := string(MustBeDString(args[0]))
                count := int(MustBeDInt(args[1]))

                if count < 0 {
                    count = 0
                }

                if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(len(s)*count)); err != nil {
                    return nil, err
                }
                return NewDString(strings.Repeat(s, count)), nil
            },
            Info: "Concatenates `input` `repeat_counter` number of times.<br/><br/>For example, " +
                "`repeat('dog', 2)` returns `dogdog`.",
        },
    },

    "ascii": {stringBuiltin1(func(_ *EvalContext, s string) (Datum, error) {
        for _, ch := range s {
            return NewDInt(DInt(ch)), nil
        }
        return nil, errEmptyInputString
    }, TypeInt, "Calculates the ASCII value for the first character in `val`.")},

    "md5": hashBuiltin(
        func() hash.Hash { return md5.New() },
        "Calculates the MD5 hash value of a set of values.",
    ),

    "sha1": hashBuiltin(
        func() hash.Hash { return sha1.New() },
        "Calculates the SHA1 hash value of a set of values.",
    ),

    "sha256": hashBuiltin(
        func() hash.Hash { return sha256.New() },
        "Calculates the SHA256 hash value of a set of values.",
    ),

    "sha512": hashBuiltin(
        func() hash.Hash { return sha512.New() },
        "Calculates the SHA512 hash value of a set of values.",
    ),

    "fnv32": hash32Builtin(
        func() hash.Hash32 { return fnv.New32() },
        "Calculates the 32-bit FNV-1 hash value of a set of values.",
    ),

    "fnv32a": hash32Builtin(
        func() hash.Hash32 { return fnv.New32a() },
        "Calculates the 32-bit FNV-1a hash value of a set of values.",
    ),

    "fnv64": hash64Builtin(
        func() hash.Hash64 { return fnv.New64() },
        "Calculates the 64-bit FNV-1 hash value of a set of values.",
    ),

    "fnv64a": hash64Builtin(
        func() hash.Hash64 { return fnv.New64a() },
        "Calculates the 64-bit FNV-1a hash value of a set of values.",
    ),

    "crc32ieee": hash32Builtin(
        func() hash.Hash32 { return crc32.New(crc32.IEEETable) },
        "Calculates the CRC-32 hash using the IEEE polynomial.",
    ),

    "crc32c": hash32Builtin(
        func() hash.Hash32 { return crc32.New(crc32.MakeTable(crc32.Castagnoli)) },
        "Calculates the CRC-32 hash using the Castagnoli polynomial.",
    ),

    "to_hex": {
        Builtin{
            Types:      ArgTypes{{"val", TypeInt}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                return NewDString(fmt.Sprintf("%x", int64(MustBeDInt(args[0])))), nil
            },
            Info: "Converts `val` to its hexadecimal representation.",
        },
        Builtin{
            Types:      ArgTypes{{"val", TypeBytes}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                bytes := *(args[0].(*DBytes))
                return NewDString(fmt.Sprintf("%x", []byte(bytes))), nil
            },
            Info: "Converts `val` to its hexadecimal representation.",
        },
    },

    "strpos": {stringBuiltin2("input", "find", func(_ *EvalContext, s, substring string) (Datum, error) {
        index := strings.Index(s, substring)
        if index < 0 {
            return DZero, nil
        }

        return NewDInt(DInt(utf8.RuneCountInString(s[:index]) + 1)), nil
    }, TypeInt, "Calculates the position where the string `find` begins in `input`. <br/><br/>For"+
        " example, `strpos('doggie', 'gie')` returns `4`.")},

    "overlay": {
        Builtin{
            Types: ArgTypes{
                {"input", TypeString},
                {"overlay_val", TypeString},
                {"start_pos", TypeInt},
            },
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                s := string(MustBeDString(args[0]))
                to := string(MustBeDString(args[1]))
                pos := int(MustBeDInt(args[2]))
                size := utf8.RuneCountInString(to)
                return overlay(s, to, pos, size)
            },
            Info: "Replaces characters in `input` with `overlay_val` starting at `start_pos` " +
                "(begins at 1). <br/><br/>For example, `overlay('doggie', 'CAT', 2)` returns " +
                "`dCATie`.",
        },
        Builtin{
            Types: ArgTypes{
                {"input", TypeString},
                {"overlay_val", TypeString},
                {"start_pos", TypeInt},
                {"end_pos", TypeInt},
            },
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                s := string(MustBeDString(args[0]))
                to := string(MustBeDString(args[1]))
                pos := int(MustBeDInt(args[2]))
                size := int(MustBeDInt(args[3]))
                return overlay(s, to, pos, size)
            },
            Info: "Deletes the characters in `input` between `start_pos` and `end_pos` (count " +
                "starts at 1), and then insert `overlay_val` at `start_pos`.",
        },
    },

    "btrim": {
        stringBuiltin2("input", "trim_chars", func(_ *EvalContext, s, chars string) (Datum, error) {
            return NewDString(strings.Trim(s, chars)), nil
        }, TypeString, "Removes any characters included in `trim_chars` from the beginning or end"+
            " of `input` (applies recursively). <br/><br/>For example, `btrim('doggie', 'eod')` "+
            "returns `ggi`."),
        stringBuiltin1(func(_ *EvalContext, s string) (Datum, error) {
            return NewDString(strings.TrimSpace(s)), nil
        }, TypeString, "Removes all spaces from the beginning and end of `val`."),
    },

    "ltrim": {
        stringBuiltin2("input", "trim_chars", func(_ *EvalContext, s, chars string) (Datum, error) {
            return NewDString(strings.TrimLeft(s, chars)), nil
        }, TypeString, "Removes any characters included in `trim_chars` from the beginning "+
            "(left-hand side) of `input` (applies recursively). <br/><br/>For example, "+
            "`ltrim('doggie', 'od')` returns `ggie`."),
        stringBuiltin1(func(_ *EvalContext, s string) (Datum, error) {
            return NewDString(strings.TrimLeftFunc(s, unicode.IsSpace)), nil
        }, TypeString, "Removes all spaces from the beginning (left-hand side) of `val`."),
    },

    "rtrim": {
        stringBuiltin2("input", "trim_chars", func(_ *EvalContext, s, chars string) (Datum, error) {
            return NewDString(strings.TrimRight(s, chars)), nil
        }, TypeString, "Removes any characters included in `trim_chars` from the end (right-hand "+
            "side) of `input` (applies recursively). <br/><br/>For example, `rtrim('doggie', 'ei')` "+
            "returns `dogg`."),
        stringBuiltin1(func(_ *EvalContext, s string) (Datum, error) {
            return NewDString(strings.TrimRightFunc(s, unicode.IsSpace)), nil
        }, TypeString, "Removes all spaces from the end (right-hand side) of `val`."),
    },

    "reverse": {stringBuiltin1(func(evalCtx *EvalContext, s string) (Datum, error) {
        if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(len(s))); err != nil {
            return nil, err
        }
        runes := []rune(s)
        for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
            runes[i], runes[j] = runes[j], runes[i]
        }
        return NewDString(string(runes)), nil
    }, TypeString, "Reverses the order of the string's characters.")},

    "replace": {stringBuiltin3(
        "input", "find", "replace",
        func(evalCtx *EvalContext, input, from, to string) (Datum, error) {
            result := strings.Replace(input, from, to, -1)
            if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(len(result))); err != nil {
                return nil, err
            }
            return NewDString(result), nil
        },
        TypeString,
        "Replaces all occurrences of `find` with `replace` in `input`",
    )},

    "translate": {stringBuiltin3(
        "input", "find", "replace",
        func(evalCtx *EvalContext, s, from, to string) (Datum, error) {
            if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(len(s))); err != nil {
                return nil, err
            }
            const deletionRune = utf8.MaxRune + 1
            translation := make(map[rune]rune, len(from))
            for _, fromRune := range from {
                toRune, size := utf8.DecodeRuneInString(to)
                if toRune == utf8.RuneError {
                    toRune = deletionRune
                } else {
                    to = to[size:]
                }
                translation[fromRune] = toRune
            }

            runes := make([]rune, 0, len(s))
            for _, c := range s {
                if t, ok := translation[c]; ok {
                    if t != deletionRune {
                        runes = append(runes, t)
                    }
                } else {
                    runes = append(runes, c)
                }
            }
            return NewDString(string(runes)), nil
        }, TypeString, "In `input`, replaces the first character from `find` with the first "+
            "character in `replace`; repeat for each character in `find`. <br/><br/>For example, "+
            "`translate('doggie', 'dog', '123');` returns `1233ie`.")},

    "regexp_extract": {
        Builtin{
            Types:      ArgTypes{{"input", TypeString}, {"regex", TypeString}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                s := string(MustBeDString(args[0]))
                pattern := string(MustBeDString(args[1]))
                return regexpExtract(ctx, s, pattern, `\`)
            },
            Info: "Returns the first match for the Regular Expression `regex` in `input`.",
        },
    },

    "regexp_replace": {
        Builtin{
            Types: ArgTypes{
                {"input", TypeString},
                {"regex", TypeString},
                {"replace", TypeString},
            },
            ReturnType: fixedReturnType(TypeString),
            fn: func(evalCtx *EvalContext, args Datums) (Datum, error) {
                s := string(MustBeDString(args[0]))
                pattern := string(MustBeDString(args[1]))
                to := string(MustBeDString(args[2]))
                result, err := regexpReplace(evalCtx, s, pattern, to, "")
                if err != nil {
                    return nil, err
                }
                if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(len(string(MustBeDString(result))))); err != nil {
                    return nil, err
                }
                return result, nil
            },
            Info: "Replaces matches for the Regular Expression `regex` in `input` with the " +
                "Regular Expression `replace`.",
        },
        Builtin{
            Types: ArgTypes{
                {"input", TypeString},
                {"regex", TypeString},
                {"replace", TypeString},
                {"flags", TypeString},
            },
            ReturnType: fixedReturnType(TypeString),
            fn: func(evalCtx *EvalContext, args Datums) (Datum, error) {
                s := string(MustBeDString(args[0]))
                pattern := string(MustBeDString(args[1]))
                to := string(MustBeDString(args[2]))
                sqlFlags := string(MustBeDString(args[3]))
                result, err := regexpReplace(evalCtx, s, pattern, to, sqlFlags)
                if err != nil {
                    return nil, err
                }
                if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(len(string(MustBeDString(result))))); err != nil {
                    return nil, err
                }
                return result, nil
            },
            Info: "Replaces matches for the Regular Expression `regex` in `input` with the Regular " +
                "Expression `replace` using `flags`.<br/><br/>CockroachDB supports the following " +
                "flags:<br/><br/>&#8226; **c**: Case-sensitive matching<br/><br/>&#8226; **g**: " +
                "Global matching (match each substring instead of only the first).<br/><br/>&#8226; " +
                "**i**: Case-insensitive matching<br/><br/>&#8226; **m** or **n**: Newline-sensitive " +
                "`.` and negated brackets (`[^...]`) do not match newline characters (preventing " +
                "matching: matches from crossing newlines unless explicitly defined to); `^` and " +
                "`$` match the space before and after newline characters respectively (so characters " +
                "between newline characters are treated as if they're on a separate line).<br/>" +
                "<br/>&#8226; **p**: Partial newline-sensitive matching: `.` and negated brackets " +
                "(`[^...]`) do not match newline characters (preventing matches from crossing " +
                "newlines unless explicitly defined to), but `^` and `$` still only match the " +
                "beginning and end of `val`.<br/><br/>&#8226; **s**: Newline-insensitive " +
                "matching *(default)*.<br/><br/>&#8226; **w**: Inverse partial newline-sensitive " +
                "matching:`.` and negated brackets (`[^...]`) *do* match newline characters, but  `^` " +
                "and `$` match the space before and after newline characters respectively (so " +
                "characters between newline characters are treated as if they're on a separate line).",
        },
    },

    "initcap": {stringBuiltin1(func(evalCtx *EvalContext, s string) (Datum, error) {
        if err := evalCtx.ActiveMemAcc.Grow(evalCtx.Ctx(), int64(len(s))); err != nil {
            return nil, err
        }
        return NewDString(strings.Title(strings.ToLower(s))), nil
    }, TypeString, "Capitalizes the first letter of `val`.")},

    "left": {
        Builtin{
            Types:      ArgTypes{{"input", TypeBytes}, {"return_set", TypeInt}},
            ReturnType: fixedReturnType(TypeBytes),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                bytes := []byte(*args[0].(*DBytes))
                n := int(MustBeDInt(args[1]))

                if n < -len(bytes) {
                    n = 0
                } else if n < 0 {
                    n = len(bytes) + n
                } else if n > len(bytes) {
                    n = len(bytes)
                }
                return NewDBytes(DBytes(bytes[:n])), nil
            },
            Info: "Returns the first `return_set` bytes from `input`.",
        },
        Builtin{
            Types:      ArgTypes{{"input", TypeString}, {"return_set", TypeInt}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                runes := []rune(string(MustBeDString(args[0])))
                n := int(MustBeDInt(args[1]))

                if n < -len(runes) {
                    n = 0
                } else if n < 0 {
                    n = len(runes) + n
                } else if n > len(runes) {
                    n = len(runes)
                }
                return NewDString(string(runes[:n])), nil
            },
            Info: "Returns the first `return_set` characters from `input`.",
        },
    },

    "right": {
        Builtin{
            Types:      ArgTypes{{"input", TypeBytes}, {"return_set", TypeInt}},
            ReturnType: fixedReturnType(TypeBytes),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                bytes := []byte(*args[0].(*DBytes))
                n := int(MustBeDInt(args[1]))

                if n < -len(bytes) {
                    n = 0
                } else if n < 0 {
                    n = len(bytes) + n
                } else if n > len(bytes) {
                    n = len(bytes)
                }
                return NewDBytes(DBytes(bytes[len(bytes)-n:])), nil
            },
            Info: "Returns the last `return_set` bytes from `input`.",
        },
        Builtin{
            Types:      ArgTypes{{"input", TypeString}, {"return_set", TypeInt}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                runes := []rune(string(MustBeDString(args[0])))
                n := int(MustBeDInt(args[1]))

                if n < -len(runes) {
                    n = 0
                } else if n < 0 {
                    n = len(runes) + n
                } else if n > len(runes) {
                    n = len(runes)
                }
                return NewDString(string(runes[len(runes)-n:])), nil
            },
            Info: "Returns the last `return_set` characters from `input`.",
        },
    },

    "random": {
        Builtin{
            Types:                   ArgTypes{},
            ReturnType:              fixedReturnType(TypeFloat),
            impure:                  true,
            needsRepeatedEvaluation: true,
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                return NewDFloat(DFloat(rand.Float64())), nil
            },
            Info: "Returns a random float between 0 and 1.",
        },
    },

    "unique_rowid": {
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeInt),
            category:   categoryIDGeneration,
            impure:     true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                return NewDInt(GenerateUniqueInt(ctx.NodeID)), nil
            },
            Info: "Returns a unique ID used by CockroachDB to generate unique row IDs if a " +
                "Primary Key isn't defined for the table. The value is a combination of the " +
                " insert timestamp and the ID of the node executing the statement, which " +
                " guarantees this combination is globally unique.",
        },
    },

    "experimental_uuid_v4": {uuidV4Impl},
    "uuid_v4":              {uuidV4Impl},

    "greatest": {
        Builtin{
            Types:      HomogeneousType{},
            ReturnType: identityReturnType(0),
            category:   categoryComparison,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                return pickFromTuple(ctx, true, args)
            },
            Info: "Returns the element with the greatest value.",
        },
    },

    "least": {
        Builtin{
            Types:      HomogeneousType{},
            ReturnType: identityReturnType(0),
            category:   categoryComparison,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                return pickFromTuple(ctx, false, args)
            },
            Info: "Returns the element with the lowest value.",
        },
    },

    "experimental_strftime": {
        Builtin{
            Types:      ArgTypes{{"input", TypeTimestamp}, {"extract_format", TypeString}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                fromTime := args[0].(*DTimestamp).Time
                format := string(MustBeDString(args[1]))
                t, err := strtime.Strftime(fromTime, format)
                if err != nil {
                    return nil, err
                }
                return NewDString(t), nil
            },
            Info: "From `input`, extracts and formats the time as identified in `extract_format` " +
                "using standard `strftime` notation (though not all formatting is supported).",
        },
        Builtin{
            Types:      ArgTypes{{"input", TypeDate}, {"extract_format", TypeString}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                fromTime := time.Unix(int64(*args[0].(*DDate))*secondsInDay, 0).UTC()
                format := string(MustBeDString(args[1]))
                t, err := strtime.Strftime(fromTime, format)
                if err != nil {
                    return nil, err
                }
                return NewDString(t), nil
            },
            Info: "From `input`, extracts and formats the time as identified in `extract_format` " +
                "using standard `strftime` notation (though not all formatting is supported).",
        },
        Builtin{
            Types:      ArgTypes{{"input", TypeTimestampTZ}, {"extract_format", TypeString}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                fromTime := args[0].(*DTimestampTZ).Time
                format := string(MustBeDString(args[1]))
                t, err := strtime.Strftime(fromTime, format)
                if err != nil {
                    return nil, err
                }
                return NewDString(t), nil
            },
            Info: "From `input`, extracts and formats the time as identified in `extract_format` " +
                "using standard `strftime` notation (though not all formatting is supported).",
        },
    },

    "experimental_strptime": {
        Builtin{
            Types:      ArgTypes{{"input", TypeString}, {"format", TypeString}},
            ReturnType: fixedReturnType(TypeTimestampTZ),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                toParse := string(MustBeDString(args[0]))
                format := string(MustBeDString(args[1]))
                t, err := strtime.Strptime(toParse, format)
                if err != nil {
                    return nil, err
                }
                return MakeDTimestampTZ(t.UTC(), time.Microsecond), nil
            },
            Info: "Returns `input` as a timestamptz using `format` (which uses standard " +
                "`strptime` formatting).",
        },
    },

    "age": {
        Builtin{
            Types:      ArgTypes{{"val", TypeTimestampTZ}},
            ReturnType: fixedReturnType(TypeInterval),
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                return timestampMinusBinOp.fn(ctx, ctx.GetTxnTimestamp(time.Microsecond), args[0])
            },
            Info: "Calculates the interval between `val` and the current time.",
        },
        Builtin{
            Types:      ArgTypes{{"begin", TypeTimestampTZ}, {"end", TypeTimestampTZ}},
            ReturnType: fixedReturnType(TypeInterval),
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                return timestampMinusBinOp.fn(ctx, args[0], args[1])
            },
            Info: "Calculates the interval between `begin` and `end`.",
        },
    },

    "current_date": {
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeDate),
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                t := ctx.GetTxnTimestamp(time.Microsecond).Time
                return NewDDateFromTime(t, ctx.GetLocation()), nil
            },
            Info: "Returns the current date.",
        },
    },

    "now":                   txnTSImpl,
    "current_timestamp":     txnTSImpl,
    "transaction_timestamp": txnTSImpl,

    "statement_timestamp": {
        Builtin{
            Types:             ArgTypes{},
            ReturnType:        fixedReturnType(TypeTimestampTZ),
            preferredOverload: true,
            impure:            true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                return MakeDTimestampTZ(ctx.GetStmtTimestamp(), time.Microsecond), nil
            },
            Info: "Returns the current statement's timestamp.",
        },
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeTimestamp),
            impure:     true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                return MakeDTimestamp(ctx.GetStmtTimestamp(), time.Microsecond), nil
            },
            Info: "Returns the current statement's timestamp.",
        },
    },

    "cluster_logical_timestamp": {
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeDecimal),
            category:   categorySystemInfo,
            impure:     true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                return ctx.GetClusterTimestamp(), nil
            },
            Info: "This function is used only by CockroachDB's developers for testing purposes.",
        },
    },

    "clock_timestamp": {
        Builtin{
            Types:             ArgTypes{},
            ReturnType:        fixedReturnType(TypeTimestampTZ),
            preferredOverload: true,
            impure:            true,
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                return MakeDTimestampTZ(timeutil.Now(), time.Microsecond), nil
            },
            Info: "Returns the current wallclock time.",
        },
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeTimestamp),
            impure:     true,
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                return MakeDTimestamp(timeutil.Now(), time.Microsecond), nil
            },
            Info: "Returns the current wallclock time.",
        },
    },

    "extract": {
        Builtin{
            Types:      ArgTypes{{"element", TypeString}, {"input", TypeTimestamp}},
            ReturnType: fixedReturnType(TypeInt),
            category:   categoryDateAndTime,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {

                fromTS := args[1].(*DTimestamp)
                timeSpan := strings.ToLower(string(MustBeDString(args[0])))
                return extractStringFromTimestamp(ctx, fromTS.Time, timeSpan)
            },
            Info: "Extracts `element` from `input`. Compatible `elements` are: <br/>&#8226; " +
                "year<br/>&#8226; quarter<br/>&#8226; month<br/>&#8226; week<br/>&#8226; " +
                "dayofweek<br/>&#8226; dayofyear<br/>&#8226; hour<br/>&#8226; minute<br/>&#8226; " +
                "second<br/>&#8226; millisecond<br/>&#8226; microsecond<br/>&#8226; epoch",
        },
        Builtin{
            Types:      ArgTypes{{"element", TypeString}, {"input", TypeDate}},
            ReturnType: fixedReturnType(TypeInt),
            category:   categoryDateAndTime,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                timeSpan := strings.ToLower(string(MustBeDString(args[0])))
                date := args[1].(*DDate)
                fromTSTZ := MakeDTimestampTZFromDate(ctx.GetLocation(), date)
                return extractStringFromTimestamp(ctx, fromTSTZ.Time, timeSpan)
            },
            Info: "Extracts `element` from `input`. Compatible `elements` are: <br/>&#8226; " +
                "year<br/>&#8226; quarter<br/>&#8226; month<br/>&#8226; week<br/>&#8226; " +
                "dayofweek<br/>&#8226; dayofyear<br/>&#8226; hour<br/>&#8226; minute<br/>&#8226; " +
                "second<br/>&#8226; millisecond<br/>&#8226; microsecond<br/>&#8226; epoch",
        },
    },

    "extract_duration": {
        Builtin{
            Types:      ArgTypes{{"element", TypeString}, {"input", TypeInterval}},
            ReturnType: fixedReturnType(TypeInt),
            category:   categoryDateAndTime,
            fn: func(_ *EvalContext, args Datums) (Datum, error) {

                fromInterval := *args[1].(*DInterval)
                timeSpan := strings.ToLower(string(MustBeDString(args[0])))
                switch timeSpan {
                case "hour", "hours":
                    return NewDInt(DInt(fromInterval.Nanos / int64(time.Hour))), nil

                case "minute", "minutes":
                    return NewDInt(DInt(fromInterval.Nanos / int64(time.Minute))), nil

                case "second", "seconds":
                    return NewDInt(DInt(fromInterval.Nanos / int64(time.Second))), nil

                case "millisecond", "milliseconds":

                    return NewDInt(DInt(fromInterval.Nanos / int64(time.Millisecond))), nil

                case "microsecond", "microseconds":
                    return NewDInt(DInt(fromInterval.Nanos / int64(time.Microsecond))), nil

                default:
                    return nil, fmt.Errorf("unsupported timespan: %s", timeSpan)
                }
            },
            Info: "Extracts `element` from `input`. Compatible `elements` are: <br/>&#8226; hour" +
                "<br/>&#8226; minute<br/>&#8226; second<br/>&#8226; millisecond<br/>&#8226; " +
                "microsecond",
        },
    },

    "abs": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Abs(x))), nil
        }, "Calculates the absolute value of `val`."),
        decimalBuiltin1(func(x *apd.Decimal) (Datum, error) {
            dd := &DDecimal{}
            dd.Abs(x)
            return dd, nil
        }, "Calculates the absolute value of `val`."),
        Builtin{
            Types:      ArgTypes{{"val", TypeInt}},
            ReturnType: fixedReturnType(TypeInt),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                x := MustBeDInt(args[0])
                switch {
                case x == math.MinInt64:
                    return nil, errAbsOfMinInt64
                case x < 0:
                    return NewDInt(-x), nil
                }
                return args[0], nil
            },
            Info: "Calculates the absolute value of `val`.",
        },
    },

    "acos": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Acos(x))), nil
        }, "Calculates the inverse cosine of `val`."),
    },

    "asin": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Asin(x))), nil
        }, "Calculates the inverse sine of `val`."),
    },

    "atan": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Atan(x))), nil
        }, "Calculates the inverse tangent of `val`."),
    },

    "atan2": {
        floatBuiltin2("x", "y", func(x, y float64) (Datum, error) {
            return NewDFloat(DFloat(math.Atan2(x, y))), nil
        }, "Calculates the inverse tangent of `x`/`y`."),
    },

    "cbrt": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Cbrt(x))), nil
        }, "Calculates the cube root (&#8731;) of `val`."),
        decimalBuiltin1(func(x *apd.Decimal) (Datum, error) {
            dd := &DDecimal{}
            _, err := DecimalCtx.Cbrt(&dd.Decimal, x)
            return dd, err
        }, "Calculates the cube root (&#8731;) of `val`."),
    },

    "ceil":    ceilImpl,
    "ceiling": ceilImpl,

    "cos": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Cos(x))), nil
        }, "Calculates the cosine of `val`."),
    },

    "cot": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(1 / math.Tan(x))), nil
        }, "Calculates the cotangent of `val`."),
    },

    "degrees": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(180.0 * x / math.Pi)), nil
        }, "Converts `val` as a radian value to a degree value."),
    },

    "div": {
        floatBuiltin2("x", "y", func(x, y float64) (Datum, error) {
            return NewDFloat(DFloat(math.Trunc(x / y))), nil
        }, "Calculates the integer quotient of `x`/`y`."),
        decimalBuiltin2("x", "y", func(x, y *apd.Decimal) (Datum, error) {
            if y.Sign() == 0 {
                return nil, errDivByZero
            }
            dd := &DDecimal{}
            _, err := HighPrecisionCtx.QuoInteger(&dd.Decimal, x, y)
            return dd, err
        }, "Calculates the integer quotient of `x`/`y`."),
        {
            Types:      ArgTypes{{"x", TypeInt}, {"y", TypeInt}},
            ReturnType: fixedReturnType(TypeInt),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                y := MustBeDInt(args[1])
                if y == 0 {
                    return nil, errDivByZero
                }
                x := MustBeDInt(args[0])
                return NewDInt(x / y), nil
            },
            Info: "Calculates the integer quotient of `x`/`y`.",
        },
    },

    "exp": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Exp(x))), nil
        }, "Calculates *e* ^ `val`."),
        decimalBuiltin1(func(x *apd.Decimal) (Datum, error) {
            dd := &DDecimal{}
            _, err := DecimalCtx.Exp(&dd.Decimal, x)
            return dd, err
        }, "Calculates *e* ^ `val`."),
    },

    "floor": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Floor(x))), nil
        }, "Calculates the largest integer not greater than `val`."),
        decimalBuiltin1(func(x *apd.Decimal) (Datum, error) {
            dd := &DDecimal{}
            _, err := ExactCtx.Floor(&dd.Decimal, x)
            return dd, err
        }, "Calculates the largest integer not greater than `val`."),
    },

    "isnan": {
        Builtin{

            Types:      ArgTypes{{"val", TypeFloat}},
            ReturnType: fixedReturnType(TypeBool),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                return MakeDBool(DBool(isNaN(args[0]))), nil
            },
            Info: "Returns true if `val` is NaN, false otherwise.",
        },
        Builtin{
            Types:      ArgTypes{{"val", TypeDecimal}},
            ReturnType: fixedReturnType(TypeBool),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                return MakeDBool(DBool(isNaN(args[0]))), nil
            },
            Info: "Returns true if `val` is NaN, false otherwise.",
        },
    },

    "ln": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Log(x))), nil
        }, "Calculates the natural log of `val`."),
        decimalLogFn(DecimalCtx.Ln, "Calculates the natural log of `val`."),
    },

    "log": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Log10(x))), nil
        }, "Calculates the base 10 log of `val`."),
        decimalLogFn(DecimalCtx.Log10, "Calculates the base 10 log of `val`."),
    },

    "mod": {
        floatBuiltin2("x", "y", func(x, y float64) (Datum, error) {
            return NewDFloat(DFloat(math.Mod(x, y))), nil
        }, "Calculates `x`%`y`."),
        decimalBuiltin2("x", "y", func(x, y *apd.Decimal) (Datum, error) {
            if y.Sign() == 0 {
                return nil, errZeroModulus
            }
            dd := &DDecimal{}
            _, err := HighPrecisionCtx.Rem(&dd.Decimal, x, y)
            return dd, err
        }, "Calculates `x`%`y`."),
        Builtin{
            Types:      ArgTypes{{"x", TypeInt}, {"y", TypeInt}},
            ReturnType: fixedReturnType(TypeInt),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                y := MustBeDInt(args[1])
                if y == 0 {
                    return nil, errZeroModulus
                }
                x := MustBeDInt(args[0])
                return NewDInt(x % y), nil
            },
            Info: "Calculates `x`%`y`.",
        },
    },

    "pi": {
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeFloat),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                return NewDFloat(math.Pi), nil
            },
            Info: "Returns the value for pi (3.141592653589793).",
        },
    },

    "pow":   powImpls,
    "power": powImpls,

    "radians": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(x * math.Pi / 180.0)), nil
        }, "Converts `val` as a degree value to a radians value."),
    },

    "round": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(round(x))), nil
        }, "Rounds `val` to the nearest integer using half to even (banker's) rounding."),
        decimalBuiltin1(func(x *apd.Decimal) (Datum, error) {
            return roundDecimal(x, 0)
        }, "Rounds `val` to the nearest integer, half away from zero: "+
            "ROUND(+/-2.4) = +/-2, ROUND(+/-2.5) = +/-3."),
        Builtin{
            Types:      ArgTypes{{"input", TypeFloat}, {"decimal_accuracy", TypeInt}},
            ReturnType: fixedReturnType(TypeFloat),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                var x apd.Decimal
                if _, err := x.SetFloat64(float64(*args[0].(*DFloat))); err != nil {
                    return nil, err
                }

                scale := int32(MustBeDInt(args[1]))

                var d apd.Decimal
                if _, err := RoundCtx.Quantize(&d, &x, -scale); err != nil {
                    return nil, err
                }

                f, err := d.Float64()
                if err != nil {
                    return nil, err
                }

                return NewDFloat(DFloat(f)), nil
            },
            Info: "Keeps `decimal_accuracy` number of figures to the right of the zero position " +
                " in `input` using half to even (banker's) rounding.",
        },
        Builtin{
            Types:      ArgTypes{{"input", TypeDecimal}, {"decimal_accuracy", TypeInt}},
            ReturnType: fixedReturnType(TypeDecimal),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {

                scale := int32(MustBeDInt(args[1]))
                return roundDecimal(&args[0].(*DDecimal).Decimal, scale)
            },
            Info: "Keeps `decimal_accuracy` number of figures to the right of the zero position " +
                " in `input using half away from zero rounding. If `decimal_accuracy` " +
                "is not in the range -2^31...(2^31-1), the results are undefined.",
        },
    },

    "sin": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Sin(x))), nil
        }, "Calculates the sine of `val`."),
    },

    "sign": {
        floatBuiltin1(func(x float64) (Datum, error) {
            switch {
            case x < 0:
                return NewDFloat(-1), nil
            case x == 0:
                return NewDFloat(0), nil
            }
            return NewDFloat(1), nil
        }, "Determines the sign of `val`: **1** for positive; **0** for 0 values; **-1** for "+
            "negative."),
        decimalBuiltin1(func(x *apd.Decimal) (Datum, error) {
            d := &DDecimal{}
            d.Decimal.SetCoefficient(int64(x.Sign()))
            return d, nil
        }, "Determines the sign of `val`: **1** for positive; **0** for 0 values; **-1** for "+
            "negative."),
        Builtin{
            Types:      ArgTypes{{"val", TypeInt}},
            ReturnType: fixedReturnType(TypeInt),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                x := MustBeDInt(args[0])
                switch {
                case x < 0:
                    return NewDInt(-1), nil
                case x == 0:
                    return DZero, nil
                }
                return NewDInt(1), nil
            },
            Info: "Determines the sign of `val`: **1** for positive; **0** for 0 values; **-1** " +
                "for negative.",
        },
    },

    "sqrt": {
        floatBuiltin1(func(x float64) (Datum, error) {

            if x < 0 {
                return nil, errSqrtOfNegNumber
            }
            return NewDFloat(DFloat(math.Sqrt(x))), nil
        }, "Calculates the square root of `val`."),
        decimalBuiltin1(func(x *apd.Decimal) (Datum, error) {
            if x.Sign() < 0 {
                return nil, errSqrtOfNegNumber
            }
            dd := &DDecimal{}
            _, err := DecimalCtx.Sqrt(&dd.Decimal, x)
            return dd, err
        }, "Calculates the square root of `val`."),
    },

    "tan": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Tan(x))), nil
        }, "Calculates the tangent of `val`."),
    },

    "trunc": {
        floatBuiltin1(func(x float64) (Datum, error) {
            return NewDFloat(DFloat(math.Trunc(x))), nil
        }, "Truncates the decimal values of `val`."),
        decimalBuiltin1(func(x *apd.Decimal) (Datum, error) {

            dd := &DDecimal{}
            frac := new(apd.Decimal)
            x.Modf(&dd.Decimal, frac)
            return dd, nil
        }, "Truncates the decimal values of `val`."),
    },

    "to_english": {
        Builtin{
            Types:      ArgTypes{{"val", TypeInt}},
            ReturnType: fixedReturnType(TypeString),
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                val := int(*args[0].(*DInt))
                var buf bytes.Buffer
                if val < 0 {
                    buf.WriteString("minus-")
                    val = -val
                }
                var digits []string
                digits = append(digits, digitNames[val%10])
                for val > 9 {
                    val /= 10
                    digits = append(digits, digitNames[val%10])
                }
                for i := len(digits) - 1; i >= 0; i-- {
                    if i < len(digits)-1 {
                        buf.WriteByte('-')
                    }
                    buf.WriteString(digits[i])
                }
                return NewDString(buf.String()), nil
            },
            category: categoryString,
            Info:     "This function enunciates the value of its argument using English cardinals.",
        },
    },

    "array_length": {
        Builtin{
            Types:      ArgTypes{{"input", TypeAnyArray}, {"array_dimension", TypeInt}},
            ReturnType: fixedReturnType(TypeInt),
            category:   categorySystemInfo,
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                arr := MustBeDArray(args[0])
                dimen := int64(MustBeDInt(args[1]))
                return arrayLength(arr, dimen), nil
            },
            Info: "Calculates the length of `input` on the provided `array_dimension`. However, " +
                "because CockroachDB doesn't yet support multi-dimensional arrays, the only supported" +
                " `array_dimension` is **1**.",
        },
    },

    "array_lower": {
        Builtin{
            Types:      ArgTypes{{"input", TypeAnyArray}, {"array_dimension", TypeInt}},
            ReturnType: fixedReturnType(TypeInt),
            category:   categorySystemInfo,
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                arr := MustBeDArray(args[0])
                dimen := int64(MustBeDInt(args[1]))
                return arrayLower(arr, dimen), nil
            },
            Info: "Calculates the minimum value of `input` on the provided `array_dimension`. " +
                "However, because CockroachDB doesn't yet support multi-dimensional arrays, the only " +
                "supported `array_dimension` is **1**.",
        },
    },

    "array_upper": {
        Builtin{
            Types:      ArgTypes{{"input", TypeAnyArray}, {"array_dimension", TypeInt}},
            ReturnType: fixedReturnType(TypeInt),
            category:   categorySystemInfo,
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                arr := MustBeDArray(args[0])
                dimen := int64(MustBeDInt(args[1]))
                return arrayLength(arr, dimen), nil
            },
            Info: "Calculates the maximum value of `input` on the provided `array_dimension`. " +
                "However, because CockroachDB doesn't yet support multi-dimensional arrays, the only " +
                "supported `array_dimension` is **1**.",
        },
    },

    "version": {
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeString),
            category:   categorySystemInfo,
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                return NewDString(build.GetInfo().Short()), nil
            },
            Info: "Returns the node's version of CockroachDB.",
        },
    },

    "current_database": {
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeString),
            category:   categorySystemInfo,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                if len(ctx.Database) == 0 {
                    return DNull, nil
                }
                return NewDString(ctx.Database), nil
            },
            Info: "Returns the current database.",
        },
    },

    "current_schema": {
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeString),
            category:   categorySystemInfo,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                if len(ctx.Database) == 0 {
                    return DNull, nil
                }
                return NewDString(ctx.Database), nil
            },
            Info: "Returns the current schema. This function is provided for " +
                "compatibility with PostgreSQL. For a new CockroachDB application, " +
                "consider using current_database() instead.",
        },
    },

    "current_schemas": {
        Builtin{
            Types:      ArgTypes{{"include_pg_catalog", TypeBool}},
            ReturnType: fixedReturnType(TypeStringArray),
            category:   categorySystemInfo,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                includePgCatalog := *(args[0].(*DBool))
                schemas := NewDArray(TypeString)
                if len(ctx.Database) != 0 {
                    if err := schemas.Append(NewDString(ctx.Database)); err != nil {
                        return nil, err
                    }
                }
                for _, p := range ctx.SearchPath {
                    if !includePgCatalog && p == "pg_catalog" {
                        continue
                    }
                    if err := schemas.Append(NewDString(p)); err != nil {
                        return nil, err
                    }
                }
                return schemas, nil
            },
            Info: "Returns the current search path for unqualified names.",
        },
    },

    "crdb_internal.cluster_id": {
        Builtin{
            Types:      ArgTypes{},
            ReturnType: fixedReturnType(TypeUUID),
            category:   categorySystemInfo,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                return NewDUuid(DUuid{ctx.ClusterID}), nil
            },
            Info: "Returns the cluster ID.",
        },
    },

    "crdb_internal.force_internal_error": {
        Builtin{
            Types:      ArgTypes{{"msg", TypeString}},
            ReturnType: fixedReturnType(TypeInt),
            impure:     true,
            privileged: true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                msg := string(*args[0].(*DString))
                return nil, pgerror.NewError(pgerror.CodeInternalError, msg)
            },
            category: categorySystemInfo,
            Info:     "This function is used only by CockroachDB's developers for testing purposes.",
        },
    },

    "crdb_internal.force_panic": {
        Builtin{
            Types:      ArgTypes{{"msg", TypeString}},
            ReturnType: fixedReturnType(TypeInt),
            impure:     true,
            privileged: true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                msg := string(*args[0].(*DString))
                panic(msg)
            },
            category: categorySystemInfo,
            Info:     "This function is used only by CockroachDB's developers for testing purposes.",
        },
    },

    "crdb_internal.force_log_fatal": {
        Builtin{
            Types:      ArgTypes{{"msg", TypeString}},
            ReturnType: fixedReturnType(TypeInt),
            impure:     true,
            privileged: true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                msg := string(*args[0].(*DString))
                log.Fatal(ctx.Ctx(), msg)
                return nil, nil
            },
            category: categorySystemInfo,
            Info:     "This function is used only by CockroachDB's developers for testing purposes.",
        },
    },

    "crdb_internal.force_retry": {
        Builtin{
            Types:      ArgTypes{{"val", TypeInterval}},
            ReturnType: fixedReturnType(TypeInt),
            impure:     true,
            privileged: true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                minDuration := args[0].(*DInterval).Duration
                elapsed := duration.Duration{
                    Nanos: int64(ctx.stmtTimestamp.Sub(ctx.txnTimestamp)),
                }
                if elapsed.Compare(minDuration) < 0 {
                    return nil, roachpb.NewHandledRetryableTxnError(
                        "forced by crdb_internal.force_retry()",
                        nil,
                        roachpb.Transaction{})
                }
                return DZero, nil
            },
            category: categorySystemInfo,
            Info:     "This function is used only by CockroachDB's developers for testing purposes.",
        },
        Builtin{
            Types: ArgTypes{
                {"val", TypeInterval},
                {"txnID", TypeString}},
            ReturnType: fixedReturnType(TypeInt),
            impure:     true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                minDuration := args[0].(*DInterval).Duration
                txnID := args[1].(*DString)
                elapsed := duration.Duration{
                    Nanos: int64(ctx.stmtTimestamp.Sub(ctx.txnTimestamp)),
                }
                if elapsed.Compare(minDuration) < 0 {
                    uuid, err := uuid.FromString(string(*txnID))
                    if err != nil {
                        return nil, err
                    }
                    return nil, roachpb.NewHandledRetryableTxnError(
                        "forced by crdb_internal.force_retry()", &uuid, roachpb.Transaction{})
                }
                return DZero, nil
            },
            category: categorySystemInfo,
            Info:     "This function is used only by CockroachDB's developers for testing purposes.",
        },
    },

    "crdb_internal.no_constant_folding": {
        Builtin{
            Types:      ArgTypes{{"input", TypeAny}},
            ReturnType: identityReturnType(0),
            impure:     true,
            fn: func(_ *EvalContext, args Datums) (Datum, error) {
                return args[0], nil
            },
            category: categorySystemInfo,
            Info:     "This function is used only by CockroachDB's developers for testing purposes.",
        },
    },
}

var CmpOps = map[ComparisonOperator]cmpOpOverload{
    EQ: {
        CmpOp{
            LeftType:  TypeString,
            RightType: TypeString,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeCollatedString,
            RightType: TypeCollatedString,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeBytes,
            RightType: TypeBytes,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeBool,
            RightType: TypeBool,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeInt,
            RightType: TypeInt,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeFloat,
            RightType: TypeFloat,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeDecimal,
            RightType: TypeDecimal,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeFloat,
            RightType: TypeInt,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeInt,
            RightType: TypeFloat,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeDecimal,
            RightType: TypeInt,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeInt,
            RightType: TypeDecimal,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeDecimal,
            RightType: TypeFloat,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeFloat,
            RightType: TypeDecimal,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeDate,
            RightType: TypeDate,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeTimestamp,
            RightType: TypeTimestamp,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeTimestampTZ,
            RightType: TypeTimestampTZ,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeTimestamp,
            RightType: TypeTimestampTZ,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeTimestampTZ,
            RightType: TypeTimestamp,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeDate,
            RightType: TypeTimestampTZ,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeDate,
            RightType: TypeTimestamp,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeTimestampTZ,
            RightType: TypeDate,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeTimestamp,
            RightType: TypeDate,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeInterval,
            RightType: TypeInterval,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeUUID,
            RightType: TypeUUID,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeOid,
            RightType: TypeOid,
            fn:        cmpOpScalarEQFn,
        },
        CmpOp{
            LeftType:  TypeTuple,
            RightType: TypeTuple,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                return cmpOpTupleFn(ctx, *left.(*DTuple), *right.(*DTuple), EQ), nil
            },
        },
    },

    LT: {
        CmpOp{
            LeftType:  TypeString,
            RightType: TypeString,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeCollatedString,
            RightType: TypeCollatedString,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeBytes,
            RightType: TypeBytes,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeBool,
            RightType: TypeBool,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeInt,
            RightType: TypeInt,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeFloat,
            RightType: TypeFloat,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeDecimal,
            RightType: TypeDecimal,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeFloat,
            RightType: TypeInt,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeInt,
            RightType: TypeFloat,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeDecimal,
            RightType: TypeInt,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeInt,
            RightType: TypeDecimal,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeDecimal,
            RightType: TypeFloat,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeFloat,
            RightType: TypeDecimal,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeDate,
            RightType: TypeDate,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeTimestamp,
            RightType: TypeTimestamp,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeTimestampTZ,
            RightType: TypeTimestampTZ,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeTimestamp,
            RightType: TypeTimestampTZ,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeTimestampTZ,
            RightType: TypeTimestamp,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeDate,
            RightType: TypeTimestampTZ,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeDate,
            RightType: TypeTimestamp,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeTimestampTZ,
            RightType: TypeDate,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeTimestamp,
            RightType: TypeDate,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeInterval,
            RightType: TypeInterval,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeUUID,
            RightType: TypeUUID,
            fn:        cmpOpScalarLTFn,
        },
        CmpOp{
            LeftType:  TypeTuple,
            RightType: TypeTuple,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                return cmpOpTupleFn(ctx, *left.(*DTuple), *right.(*DTuple), LT), nil
            },
        },
    },

    LE: {
        CmpOp{
            LeftType:  TypeString,
            RightType: TypeString,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeCollatedString,
            RightType: TypeCollatedString,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeBytes,
            RightType: TypeBytes,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeBool,
            RightType: TypeBool,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeInt,
            RightType: TypeInt,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeFloat,
            RightType: TypeFloat,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeDecimal,
            RightType: TypeDecimal,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeFloat,
            RightType: TypeInt,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeInt,
            RightType: TypeFloat,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeDecimal,
            RightType: TypeInt,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeInt,
            RightType: TypeDecimal,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeDecimal,
            RightType: TypeFloat,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeFloat,
            RightType: TypeDecimal,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeDate,
            RightType: TypeDate,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeTimestamp,
            RightType: TypeTimestamp,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeTimestampTZ,
            RightType: TypeTimestampTZ,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeTimestampTZ,
            RightType: TypeTimestamp,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeTimestamp,
            RightType: TypeTimestampTZ,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeDate,
            RightType: TypeTimestampTZ,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeDate,
            RightType: TypeTimestamp,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeTimestampTZ,
            RightType: TypeDate,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeTimestamp,
            RightType: TypeDate,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeInterval,
            RightType: TypeInterval,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeUUID,
            RightType: TypeUUID,
            fn:        cmpOpScalarLEFn,
        },
        CmpOp{
            LeftType:  TypeTuple,
            RightType: TypeTuple,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                return cmpOpTupleFn(ctx, *left.(*DTuple), *right.(*DTuple), LE), nil
            },
        },
    },

    In: {
        makeEvalTupleIn(TypeBool),
        makeEvalTupleIn(TypeInt),
        makeEvalTupleIn(TypeFloat),
        makeEvalTupleIn(TypeDecimal),
        makeEvalTupleIn(TypeString),
        makeEvalTupleIn(TypeCollatedString),
        makeEvalTupleIn(TypeBytes),
        makeEvalTupleIn(TypeDate),
        makeEvalTupleIn(TypeTimestamp),
        makeEvalTupleIn(TypeTimestampTZ),
        makeEvalTupleIn(TypeInterval),
        makeEvalTupleIn(TypeUUID),
        makeEvalTupleIn(TypeTuple),
        makeEvalTupleIn(TypeOid),
    },

    Like: {
        CmpOp{
            LeftType:  TypeString,
            RightType: TypeString,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                return matchLike(ctx, left, right, false)
            },
        },
    },

    ILike: {
        CmpOp{
            LeftType:  TypeString,
            RightType: TypeString,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                return matchLike(ctx, left, right, true)
            },
        },
    },

    SimilarTo: {
        CmpOp{
            LeftType:  TypeString,
            RightType: TypeString,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                key := similarToKey(MustBeDString(right))
                return matchRegexpWithKey(ctx, left, key)
            },
        },
    },

    RegMatch: {
        CmpOp{
            LeftType:  TypeString,
            RightType: TypeString,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                key := regexpKey{s: string(MustBeDString(right)), caseInsensitive: false}
                return matchRegexpWithKey(ctx, left, key)
            },
        },
    },

    RegIMatch: {
        CmpOp{
            LeftType:  TypeString,
            RightType: TypeString,
            fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
                key := regexpKey{s: string(MustBeDString(right)), caseInsensitive: true}
                return matchRegexpWithKey(ctx, left, key)
            },
        },
    },
}

var Generators = map[string][]Builtin{
    "generate_series": {
        makeGeneratorBuiltin(
            ArgTypes{{"start", TypeInt}, {"end", TypeInt}},
            TTuple{TypeInt},
            makeSeriesGenerator,
            "Produces a virtual table containing the integer values from `start` to `end`, inclusive.",
        ),
        makeGeneratorBuiltin(
            ArgTypes{{"start", TypeInt}, {"end", TypeInt}, {"step", TypeInt}},
            TTuple{TypeInt},
            makeSeriesGenerator,
            "Produces a virtual table containing the integer values from `start` to `end`, inclusive, by increment of `step`.",
        ),
    },
    "unnest": {
        makeGeneratorBuiltinWithReturnType(
            ArgTypes{{"input", TypeAnyArray}},
            func(args []TypedExpr) Type {
                if len(args) == 0 {
                    return unknownReturnType
                }
                return TTable{Cols: TTuple{args[0].ResolvedType().(TArray).Typ}}
            },
            makeArrayGenerator,
            "Returns the input array as a set of rows",
        ),
    },
}

var OidToType = map[oid.Oid]Type{
    oid.T_anyelement:   TypeAny,
    oid.T_bool:         TypeBool,
    oid.T_bytea:        TypeBytes,
    oid.T_date:         TypeDate,
    oid.T_float4:       typeFloat4,
    oid.T_float8:       TypeFloat,
    oid.T_int2:         typeInt2,
    oid.T_int4:         typeInt4,
    oid.T_int8:         TypeInt,
    oid.T_int2vector:   TypeIntVector,
    oid.T_interval:     TypeInterval,
    oid.T_name:         TypeName,
    oid.T_numeric:      TypeDecimal,
    oid.T_oid:          TypeOid,
    oid.T_regclass:     TypeRegClass,
    oid.T_regnamespace: TypeRegNamespace,
    oid.T_regproc:      TypeRegProc,
    oid.T_regprocedure: TypeRegProcedure,
    oid.T_regtype:      TypeRegType,
    oid.T__text:        TypeStringArray,
    oid.T__int2:        typeInt2Array,
    oid.T__int4:        typeInt4Array,
    oid.T__int8:        TypeIntArray,
    oid.T_record:       TypeTuple,
    oid.T_text:         TypeString,
    oid.T_timestamp:    TypeTimestamp,
    oid.T_timestamptz:  TypeTimestampTZ,
    oid.T_uuid:         TypeUUID,
    oid.T_varchar:      typeVarChar,
}

var UnaryOps = map[UnaryOperator]unaryOpOverload{
    UnaryPlus: {
        UnaryOp{
            Typ:        TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, d Datum) (Datum, error) {
                return d, nil
            },
        },
        UnaryOp{
            Typ:        TypeFloat,
            ReturnType: TypeFloat,
            fn: func(_ *EvalContext, d Datum) (Datum, error) {
                return d, nil
            },
        },
        UnaryOp{
            Typ:        TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, d Datum) (Datum, error) {
                return d, nil
            },
        },
    },

    UnaryMinus: {
        UnaryOp{
            Typ:        TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, d Datum) (Datum, error) {
                i := MustBeDInt(d)
                if i == math.MinInt64 {
                    return nil, errIntOutOfRange
                }
                return NewDInt(-i), nil
            },
        },
        UnaryOp{
            Typ:        TypeFloat,
            ReturnType: TypeFloat,
            fn: func(_ *EvalContext, d Datum) (Datum, error) {
                return NewDFloat(-*d.(*DFloat)), nil
            },
        },
        UnaryOp{
            Typ:        TypeDecimal,
            ReturnType: TypeDecimal,
            fn: func(_ *EvalContext, d Datum) (Datum, error) {
                dec := &d.(*DDecimal).Decimal
                dd := &DDecimal{}
                dd.Decimal.Neg(dec)
                return dd, nil
            },
        },
        UnaryOp{
            Typ:        TypeInterval,
            ReturnType: TypeInterval,
            fn: func(_ *EvalContext, d Datum) (Datum, error) {
                i := d.(*DInterval).Duration
                i.Nanos = -i.Nanos
                i.Days = -i.Days
                i.Months = -i.Months
                return &DInterval{Duration: i}, nil
            },
        },
    },

    UnaryComplement: {
        UnaryOp{
            Typ:        TypeInt,
            ReturnType: TypeInt,
            fn: func(_ *EvalContext, d Datum) (Datum, error) {
                return NewDInt(^MustBeDInt(d)), nil
            },
        },
    },
}

type AggregateFunc interface {
    // Add accumulates the passed datum into the AggregateFunc.
    Add(context.Context, Datum) error

    // Result returns the current value of the accumulation. This value
    // will be a deep copy of any AggregateFunc internal state, so that
    // it will not be mutated by additional calls to Add.
    Result() (Datum, error)

    // Close closes out the AggregateFunc and allows it to release any memory it
    // requested during aggregation, and must be called upon completion of the
    // aggregation.
    Close(context.Context)
}

type AliasClause struct {
    Alias Name
    Cols  NameList
}