Hello Tim !

select id
from T2,
    (select count(*) cnt from T2) t2_cnt,
    (select maxrows from T1) max_t1
order by mydate
limit case when t2_cnt.cnt > max_t1.maxrows
    then t2_cnt.cnt - max_t1.maxrows
    else 0 end;
 
Cheers !

Not sure I understand this syntax:

    (select count(*) cnt from T2) t2_cnt,
    (select maxrows from T1) max_t1

which seems to be defining new tables, as far as I can see from the later usage such as:

   ... when t2_cnt.cnt > max_t1.maxrows ...

but I can't get that from the SQLite syntax diagrams. In any case, I get this error in the sqlite CLI:

Error: no such column: t2_cnt.cnt

so I'll have a look at max().

Not sure I understand this syntax:

    (select count(*) cnt from T2) t2_cnt,
    (select maxrows from T1) max_t1

Yes it's defining new tables it's a shortcut for:

    (select count(*) as cnt from T2) as t2_cnt,
    (select maxrows from T1) as max_t1

i am trying to like this as: select name from users, (select A_id , count(*) from event where date<=given date group by A_id order by count(*) desc ) e where users.A_id=e.a_id limit 0,5… 
OK

Does

limit max((select count(*) from T2)-(select maxrows from T1), 0)

not work?

It seems better/simpler than mine !

Thanks. That allowed me to replace six selects with two.

It seems that you just found a bug in sqlite !

====
create table T1(id integer primary key, val text);
insert into T1(val) values('1one'), ('1two'), ('1three');

create table T2(id integer primary key, val text);
insert into T2(val) values('2one'), ('2two'), ('2three'), ('2four');

select id, t2_cnt.cnt, max_t1.cnt
from T2,
    (select count(*) as cnt from T2) t2_cnt,
    (select count(*) as cnt from T1) max_t1
order by id

limit case when t2_cnt.cnt > max_t1.cnt
    then t2_cnt.cnt - max_t1.cnt
    else 0 end;
====
Ouput:
====
sqlite3 < "test.sql"
Error: near line 7: no such column: t2_cnt.cnt
====

Removing the "limit":
====
create table T1(id integer primary key, val text);
insert into T1(val) values('1one'), ('1two'), ('1three');

create table T2(id integer primary key, val text);
insert into T2(val) values('2one'), ('2two'), ('2three'), ('2four');

select id, t2_cnt.cnt, max_t1.cnt
from T2,
    (select count(*) as cnt from T2) t2_cnt,
    (select count(*) as cnt from T1) max_t1
order by id;
====
Ouput:
====
sqlite3 < "test.sql"
1|4|3
2|4|3
3|4|3
4|4|3
====

Not a bug.  

The *expression* following `LIMIT` must be a *constant expression*.

That is it must be able to be evaluated **before** the statement to which the limit applies (and must not change during execution) and therefore must not be dependent on data items contained within the query of which it is a part.

Note sure if this is documented but this is how `limit` works.

Mutatis mutandis `offset`.

You seems to be right, my bad !

Trying in Postgresql gives a better error message:
====
argument of LIMIT must not contain variables
====

The above was based on just discovered https://extendsclass.com/postgresql-online.html

With this sql:
====
create table T1(id integer primary key, val text);
insert into T1(id, val) values(1, '1one'), (2, '1two'), (3, '1three');

create table T2(id integer primary key, val text);
insert into T2(id, val) values(1, '2one'), (2, '2two'), (3, '2three'), (4, '2four');

select id, t2_cnt.cnt, max_t1.cnt
from T2,
    (select count(*) as cnt from T2) t2_cnt,
    (select count(*) as cnt from T1) max_t1
order by id
limit case when t2_cnt.cnt > max_t1.cnt
    then t2_cnt.cnt - max_t1.cnt
    else 0 end;
====

```
    select id from T2
        order by mydate desc
        limit -1
        offset (select maxrows from T1);
```

It's a clean query but has the disadvantage of scan all rows of T2.

So does this fragment, which every other suggestion includes: 

```
    select count(*) from T2
```

You are right !

And I pointed out because other people can see your/our examples and use it in other contexts where paginating using offset for big tables is not a good/wise idea.