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 = 57675

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 = 57418

const CURRENT_SCHEMA = 57417

const CURRENT_TIME = 57419

const CURRENT_TIMESTAMP = 57420

const CURRENT_USER = 57421

const CYCLE = 57422

const DATA = 57423

const DATABASE = 57424

const DATABASES = 57425

const DATE = 57426

const DAY = 57427

const DEALLOCATE = 57431

const DEC = 57428

const DECIMAL = 57429

const DEFAULT = 57430

const DEFERRABLE = 57432

const DELETE = 57433

const DESC = 57434

const DISCARD = 57435

const DISTINCT = 57436

const DO = 57437

const DOT_DOT = 57354

const DOUBLE = 57438

const DROP = 57439

const ELSE = 57440

const ENCODING = 57441

const END = 57442

const ERROR = 57361

const ESCAPE = 57443

const EXCEPT = 57444

const EXECUTE = 57446

const EXISTS = 57445

const EXPERIMENTAL_FINGERPRINTS = 57447

const EXPLAIN = 57448

const EXTRACT = 57449

const EXTRACT_DURATION = 57450

const FALSE = 57451

const FAMILY = 57452

const FCONST = 57350

const FETCH = 57453

const FILTER = 57454

const FIRST = 57455

const FLOAT = 57456

const FLOAT4 = 57457

const FLOAT8 = 57458

const FLOORDIV = 57459

const FOLLOWING = 57460

const FOR = 57461

const FORCE_INDEX = 57462

const FOREIGN = 57463

const FROM = 57464

const FULL = 57465

const GRANT = 57466

const GRANTS = 57467

const GREATER_EQUALS = 57356

const GREATEST = 57468

const GROUP = 57469

const GROUPING = 57470

const HAVING = 57471

const HELP = 57472

const HIGH = 57473

const HOUR = 57474

const ICONST = 57349

const IDENT = 57346

const IF = 57476

const IFNULL = 57477

const ILIKE = 57478

const IN = 57479

const INCREMENTAL = 57475

const INDEX = 57481

const INDEXES = 57482

const INITIALLY = 57483

const INNER = 57484

const INSERT = 57485

const INT = 57486

const INT2 = 57488

const INT2VECTOR = 57487

const INT4 = 57489

const INT64 = 57491

const INT8 = 57490

const INTEGER = 57492

const INTERLEAVE = 57480

const INTERSECT = 57493

const INTERVAL = 57494

const INTO = 57495

const IS = 57496

const ISOLATION = 57497

const InvalidColIdx = -1

const JOB = 57498

const JOBS = 57499

const JOIN = 57500

const KEY = 57501

const KEYS = 57502

const KV = 57503

const LATERAL = 57504

const LC_COLLATE = 57506

const LC_CTYPE = 57505

const LEADING = 57507

const LEAST = 57508

const LEFT = 57509

const LESS_EQUALS = 57355

const LEVEL = 57510

const LIKE = 57511

const LIMIT = 57512

const LOCAL = 57513

const LOCALTIME = 57514

const LOCALTIMESTAMP = 57515

const LOW = 57516

const LSHIFT = 57517

const MATCH = 57518

const MINUTE = 57519

const MONTH = 57520

const MaxInt = int(MaxUint >> 1)

const MaxUint = ^uint(0)

const NAME = 57522

const NAMES = 57523

const NAN = 57521

const NATURAL = 57524

const NEXT = 57525

const NO = 57526

const NORMAL = 57528

const NOT = 57529

const NOTHING = 57530

const NOT_EQUALS = 57357

const NOT_LA = 57673

const NOT_REGIMATCH = 57360

const NOT_REGMATCH = 57358

const NO_INDEX_JOIN = 57527

const NULL = 57531

const NULLIF = 57532

const NULLS = 57533

const NUMERIC = 57534

const OF = 57535

const OFF = 57536

const OFFSET = 57537

const OID = 57538

const ON = 57539

const ONLY = 57540

const OPTIONS = 57541

const OR = 57542

const ORDER = 57543

const ORDINALITY = 57544

const OUT = 57545

const OUTER = 57546

const OVER = 57547

const OVERLAPS = 57548

const OVERLAY = 57549

const PARENT = 57550

const PARTIAL = 57551

const PARTITION = 57552

const PASSWORD = 57553

const PAUSE = 57554

const PLACEHOLDER = 57351

const PLACING = 57555

const PLANS = 57556

const POSITION = 57557

const POSTFIXOP = 57676

const PRECEDING = 57558

const PRECISION = 57559

const PREPARE = 57560

const PRIMARY = 57561

const PRIORITY = 57562

const QUERIES = 57563

const QUERY = 57564

const RANGE = 57565

const READ = 57566

const REAL = 57567

const RECURSIVE = 57568

const REF = 57569

const REFERENCES = 57570

const REGCLASS = 57571

const REGIMATCH = 57359

const REGNAMESPACE = 57574

const REGPROC = 57572

const REGPROCEDURE = 57573

const REGTYPE = 57575

const RELEASE = 57578

const RENAME = 57576

const REPEATABLE = 57577

const RESET = 57579

const RESTORE = 57580

const RESTRICT = 57581

const RESUME = 57582

const RETURNING = 57583

const REVOKE = 57584

const RIGHT = 57585

const ROLLBACK = 57586

const ROLLUP = 57587

const ROW = 57588

const ROWS = 57589

const RSHIFT = 57590

const RestartSavepointName string = "COCKROACH_RESTART"

const SAVEPOINT = 57591

const SCATTER = 57592

const SCONST = 57347

const SEARCH = 57593

const SECOND = 57594

const SELECT = 57595

const SEQUENCES = 57596

const SERIAL = 57597

const SERIALIZABLE = 57598

const SESSION = 57599

const SESSIONS = 57600

const SESSION_USER = 57601

const SET = 57602

const SETTING = 57603

const SETTINGS = 57604

const SHOW = 57605

const SIMILAR = 57606

const SIMPLE = 57607

const SMALLINT = 57608

const SMALLSERIAL = 57609

const SNAPSHOT = 57610

const SOME = 57611

const SPLIT = 57612

const SQL = 57613

const START = 57614

const STATUS = 57615

const STDIN = 57616

const STORING = 57619

const STRICT = 57617

const STRING = 57618

const SUBSTRING = 57620

const SYMMETRIC = 57621

const SYSTEM = 57622

const TABLE = 57623

const TABLES = 57624

const TEMP = 57625

const TEMPLATE = 57626

const TEMPORARY = 57627

const TESTING_RANGES = 57628

const TESTING_RELOCATE = 57629

const TEXT = 57630

const THEN = 57631

const TIME = 57632

const TIMESTAMP = 57633

const TIMESTAMPTZ = 57634

const TO = 57635

const TRACE = 57637

const TRAILING = 57636

const TRANSACTION = 57638

const TREAT = 57639

const TRIM = 57640

const TRUE = 57641

const TRUNCATE = 57642

const TYPE = 57643

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 = 57677

const UNBOUNDED = 57644

const UNCOMMITTED = 57645

const UNION = 57646

const UNIQUE = 57647

const UNKNOWN = 57648

const UPDATE = 57649

const UPSERT = 57650

const USE = 57651

const USER = 57652

const USERS = 57653

const USING = 57654

const UUID = 57655

const VALID = 57656

const VALIDATE = 57657

const VALUE = 57658

const VALUES = 57659

const VARCHAR = 57660

const VARIADIC = 57661

const VARYING = 57663

const VIEW = 57662

const WHEN = 57664

const WHERE = 57665

const WINDOW = 57666

const WITH = 57667

const WITHIN = 57668

const WITHOUT = 57669

const WITH_LA = 57674

const WRITE = 57670

const YEAR = 57671

const ZONE = 57672

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 AllBuiltinNames []string

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{}
            x.Modf(&dd.Decimal, nil)
            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_error": {
        Builtin{
            Types:      ArgTypes{{"errorCode", TypeString}, {"msg", TypeString}},
            ReturnType: fixedReturnType(TypeInt),
            impure:     true,
            fn: func(ctx *EvalContext, args Datums) (Datum, error) {
                errCode := string(*args[0].(*DString))
                msg := string(*args[1].(*DString))
                return nil, pgerror.NewError(errCode, 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
            },
        },
    },
}