`select sum(i) from range(1,10000001)t(i);` return no result

[l1t1]

I run it in psql

root@6ae32a5ffcde:/# psql 'postgresql://localhost:15432/main'
psql (15.13 (Debian 15.13-0+deb12u1), server 14)
Type "help" for help.

main=> select version();
 "version"()
-------------
 v1.4.0
(1 row)
main=> \timing on
Timing is on.
main=> select sum(i) from range(1,10000001)t(i); ---------------this line---------------
--
(1 row)

Time: 72.905 ms
main=> select count(i) from range(1,10000001)t(i);
 count(i)
----------
 10000000
(1 row)

Time: 3.482 ms
main=> select sum(i::bigint) from range(1,10000001)t(i); ---------------and this line---------------
--
(1 row)

Time: 22.043 ms

main=> explain analyze select sum(i) from range(1,10000001)t(i);
  explain_key  |                       explain_value
---------------+-----------------------------------------------------------
 analyzed_plan | ┌─────────────────────────────────────┐                  +
               | │┌───────────────────────────────────┐│                  +
               | ││    Query Profiling Information    ││                  +
               | │└───────────────────────────────────┘│                  +
               | └─────────────────────────────────────┘                  +
               | explain analyze select sum(i) from range(1,10000001)t(i);+
               | ┌────────────────────────────────────────────────┐       +
               | │┌──────────────────────────────────────────────┐│       +
               | ││              Total Time: 0.0163s             ││       +
               | │└──────────────────────────────────────────────┘│       +
               | └────────────────────────────────────────────────┘       +
               | ┌───────────────────────────┐                            +
               | │           QUERY           │                            +
               | └─────────────┬─────────────┘                            +
               | ┌─────────────┴─────────────┐                            +
               | │      EXPLAIN_ANALYZE      │                            +
               | │    ────────────────────   │                            +
               | │           0 rows          │                            +
               | │          (0.00s)          │                            +
               | └─────────────┬─────────────┘                            +
               | ┌─────────────┴─────────────┐                            +
               | │    UNGROUPED_AGGREGATE    │                            +
               | │    ────────────────────   │                            +
               | │    Aggregates: sum(#0)    │                            +
               | │                           │                            +
               | │           1 row           │                            +
               | │          (0.01s)          │                            +
               | └─────────────┬─────────────┘                            +
               | ┌─────────────┴─────────────┐                            +
               | │         PROJECTION        │                            +
               | │    ────────────────────   │                            +
               | │             i             │                            +
               | │                           │                            +
               | │      10,000,000 rows      │                            +
               | │          (0.00s)          │                            +
               | └─────────────┬─────────────┘                            +
               | ┌─────────────┴─────────────┐                            +
               | │         TABLE_SCAN        │                            +
               | │    ────────────────────   │                            +
               | │      Function: RANGE      │                            +
               | │                           │                            +
               | │      10,000,000 rows      │                            +
               | │          (0.00s)          │                            +
               | └───────────────────────────┘                            +
               |
(1 row)

[l1t1]

I found the root, type int128 isn't handled in your code
duckdb

D select sum(i) from generate_series(1,11)t(i);
┌────────┐
│ sum(i) │
│ int128 │
├────────┤
│   66   │
└────────┘

duckdb_pgwire_extension.cpp

                    case LogicalTypeId::SMALLINT:
                        row.write_int2(chunk.GetValue<int16_t>(i));
                        break;
                    case LogicalTypeId::INTEGER:
                        row.write_int4(chunk.GetValue<int32_t>(i));
                        break;
                    case LogicalTypeId::BIGINT:
                        row.write_int8(chunk.GetValue<int64_t>(i));
                        break;

psql

main=> select sum(i)::int32 from generate_series(1,11)t(i);
 CAST(sum(i) AS INTEGER)
-------------------------
                      66
(1 row)

Time: 17.682 ms
main=> select sum(i)::int64 from generate_series(1,11)t(i);
 CAST(sum(i) AS BIGINT)
------------------------
                     66
(1 row)

Time: 9.187 ms
main=> select sum(i)::int128 from generate_series(1,11)t(i);
--
(1 row)

Time: 4.600 ms

[l1t1]

pgwire::RowWriter only supports 3 int types too.

void RowWriter::write_int2(int16_t v) {
    _current_col++;
    write_numeric(_row, _writer._format_code, v, "%d");
}
void RowWriter::write_int4(int32_t v) {
    _current_col++;
    write_numeric(_row, _writer._format_code, v, "%d");
}
void RowWriter::write_int8(int64_t v) {
    _current_col++;
    write_numeric(_row, _writer._format_code, v, "%lld");
}

[l1t1]

I fixed it
add write.hpp

class RowWriter {
    void write_int16(__int128_t v);//add

add write.cpp

void RowWriter::write_int16(__int128_t v) { //add
    _current_col++;
    
    if (_writer._format_code == FormatCode::Text) {
        char buf[256];
        char *p = buf + 256;
        *--p = '\0';
        
        bool negative = false;
        __int128_t n = v;
        
        if (n < 0) {
            negative = true;
            n = -n;
        }
        
        do {
            *--p = '0' + (n % 10);
            n /= 10;
        } while (n != 0);
        
        if (negative) {
            *--p = '-';
        }
        
        int len = buf + 256 - p - 1;
        _row.put_numeric<int32_t>(len);
        _row.put_bytes(reinterpret_cast<Byte const *>(p), len);
    } else {
        // Binary 格式
        _row.put_numeric<int32_t>(sizeof(__int128_t));
        _row.put_numeric<__int128_t>(v);
    }
}

add duckdb_pgwire_extension.cpp g_typemap

static std::unordered_map<LogicalTypeId, pgwire::Oid> g_typemap = {
    {LogicalTypeId::HUGEINT, pgwire::Oid::Int8}, //add

add static pgwire::ParseHandler duckdb_handler(DatabaseInstance &db)

                    case LogicalTypeId::HUGEINT:
                        row.write_int16(static_cast<__int128_t>(chunk.GetValue<hugeint_t>(i).upper) << 64 | 
                static_cast<__int128_t>(chunk.GetValue<hugeint_t>(i).lower));