Hi All,

Can someone explain why current_date, current_time, and current_timestamp show up in the list of available functions, even though they do not have function syntax?  CLI output below.

SQLite version 3.30.0 2019-10-04 15:03:17
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
sqlite> select name from pragma_function_list where name like 'current%';
current_timestamp
current_date
current_time
sqlite> select current_date();
Error: near "(": syntax error
sqlite> select current_date;
2020-06-12

Thanks
Tom

Yes, current_date, current_time, and current_timestamp are functions that take no arguments.  They are also *special tokens* in the SQL standard in that they are "magical constants" representing the current date, time, and datetime respectively.

Ah, yes!  They show up in that [syntax diagram](https://sqlite.org/lang_expr.html) in the button-activated expansion for token **literal\_value**.

Ok I guess.  Yet the sqlite_version() function also takes no arguments but the parentheses are required.  Regardless it's no biggie.

SQLite version 3.31.1 2020-01-27 19:55:54
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
sqlite> select current_date;
2020-06-13
sqlite> select current_date();
Error: near "(": syntax error
sqlite> select sqlite_version;
Error: no such column: sqlite_version
sqlite> select sqlite_version();
3.31.1
sqlite> 

Thanks guys
Tom

As Keith said, those 3 current\_* tokens are special. The scanner (lexical analyzer) recognizes them along with all the keywords (very efficiently by using a specialized hash table) and finally reduces them to a value, TK\_CTIME\_KW, which is all the parser directly sees. They become distinguished when the original (maybe case-folded) text is looked up in the same "table" that pragma\_function\_list shows. The grammar (in parse.y) requires that there be no parenthesis, just as Keith says the SQL standard specifies and the syntax diagram I linked documents. 

Because of this special processing for just those functions, there is no reason to be surprised that sqlite\_version() needs its parentheses.

I think it was a mistake for the SQL standard to require this. Those 3 tokens act like literals in the language, but they are not constants like all other literals; they have more complex behavior such as we associate with functions. It might be considered syntactical sugar, but I think it's mainly an anomalous source of confusion such as you (and I) experienced.

> I think it was a mistake for the SQL standard to require this. Those 3 tokens act like literals in the language, but they are not constants like all other literals;

There is actually a reason for it: those constants can be used as default values in column definitions, whereas normal function calls cannot:

```sql
sqlite> create table t1(a, b default current_date);
sqlite> create table t2(a, b default strftime('%Y','now'));
Error: near "(": syntax error
sqlite> select strftime('%Y','now');
2020
sqlite> insert into t1(a) values(1); select * from t1;
1|2020-06-13
```

Why *those* specific constants are singled out probably boils down to historical behaviour on ancient platforms.

In SQLite, you can use functions in default values, but you have to surround them with parenthesis :
```sql
sqlite> create table t1(a, b default current_date);
sqlite> create table t2(a, b default strftime('%Y','now'));
Error: near "(": syntax error
sqlite> create table t2(a, b default (strftime('%Y','now')));
sqlite> insert into t2(a) values(1); select * from t2;
1|2020
```

~~~
-- 
Regards,
Kees Nuyt
~~~

Interesting.  Seems like a better name for those entities would be "global variables" as opposed to "functions". I'm all for backwards compatibility so if they are considered functions in the 40+ years of SQL nomenclature then ok.

Thank you
Tom

LIKE, REGEXP, and GLOB are also functions and "language elements".

That is, `select * from somewhere where a like 'twat%' escape '\';` is equivalent to `select * from somewhere where like('twat%', a, '\');`.  The same also applies to the GLOB and REGEXP keywords, which are also functions.

While `current_time`, `current_date`, and `current_timestamp` are "language elements", the use of those names as functions is not implemented.