Na mesma consulta INSERT, dois VALUES sendo NOW() podem retornar um horário diferente?

A hora retornada por NOW()e outras funções de data e hora são derivadas da hora de início da consulta. A THDclasse aqui é usada para conter todas as informações para a conexão. A implementaçãoNOW() da função pega esse valor e o retorna na estrutura.now_time

Os documentos doNOW() MySQL também indicam:

NOW() retorna uma hora constante que indica a hora em que a instrução começou a ser executada. ...

Você sempre obterá o mesmo NOW()valor de qualquer lugar na consulta.

MariaDB [test]> select now(),sleep(10),now();
+---------------------+-----------+---------------------+
| now()               | sleep(10) | now()               |
+---------------------+-----------+---------------------+
| 2021-03-22 14:17:05 |         0 | 2021-03-22 14:17:05 |
+---------------------+-----------+---------------------+

Vale a pena notar que isso não é por transação:

MariaDB [test]> start transaction
    -> ;
Query OK, 0 rows affected (0.00 sec)

MariaDB [test]>  select now();
+---------------------+
| now()               |
+---------------------+
| 2021-03-22 14:20:53 |
+---------------------+
1 row in set (0.00 sec)

MariaDB [test]> select sleep(2);
+----------+
| sleep(2) |
+----------+
|        0 |
+----------+
1 row in set (2.00 sec)

MariaDB [test]> select now();
+---------------------+
| now()               |
+---------------------+
| 2021-03-22 14:21:00 |
+---------------------+
1 row in set (0.00 sec)

Outro aspecto: SYSDATE()pode ser diferente, mas NOW()não pode.

mysql> select now(6), sysdate(6), now(6), sysdate(6);
+----------------------------+----------------------------+----------------------------+----------------------------+
| now(6)                     | sysdate(6)                 | now(6)                     | sysdate(6)                 |
+----------------------------+----------------------------+----------------------------+----------------------------+
| 2021-03-21 22:02:28.983211 | 2021-03-21 22:02:28.983368 | 2021-03-21 22:02:28.983211 | 2021-03-21 22:02:28.983370 |
+----------------------------+----------------------------+----------------------------+----------------------------+
1 row in set (0.00 sec)

Estou usando (6)para que possamos ver o tempo até o microssegundo. Observe como as NOWchamadas são idênticas e os menores valores. Enquanto isso, as SYSDATEligações são posteriores e não são iguais umas às outras.

----- 31-03-2006 5.0.20 e ainda não lançado 5.1.8 -- Funcionalidade adicionada ou alterada -- -----

Adicionada a opção --sysdate-is-now ao mysqld para permitir que SYSDATE() seja tratado como um alias para NOW() . Consulte Funções de data e hora . (Erro #15101)

----- 2005-09-22 5.0.13 Release Candidate -- Bugs corrigidos -- -----

A função SYSDATE() agora retorna a hora em que foi chamada. Em particular, dentro de uma rotina ou gatilho armazenado, SYSDATE() retorna a hora em que é executada, não a hora em que a rotina armazenada ou a instrução de gatilho começou a ser executada. (Erro #12480)

Não achei a resposta do @nbk satisfatória o suficiente para minhas necessidades (especialmente "Não, desde que você não tenha micro segundos em seu datetime e um servidor realmente muito lento, pode ser possível").

Então simulei uma espécie de servidor muito lento.

Meu desktop Linux MB tem 6 núcleos, eu fiz esse programa em C

#define COUNT 10000000000L

double busy() {
     volatile double z = rand() / M_PI;

     for(long l=0 ; l<COUNT ; l++) {
          z += sqrt(M_PI);
     }
     return z;
}

e no principal

 int n = atoi(*++argv); // input 10 

 while(n--) {
      if ( ! fork()) {
            printf("%d => %lf\n", n, busy());
            exit(0);
      }
 }

 pid_t wpid;
 int status = 0;
 while ((wpid = wait(&status)) > 0);

Isso torna n threads muito ocupados. Com n = 10, a área de trabalho estava muito ocupada...

Enquanto isso estava sendo executado (como root , para garantir que o sistema não tente salvar alguns recursos para si mesmo :) Eu preparei isso antes

create table a (num int auto_increment primary key,
   d1 datetime(6), d2 datetime(6), d3 datetime(6), d4 datetime(6));

e um arquivo de 1000 linhas

insert into a values(null,now(6),now(6),now(6),now(6));

Então, quando o PC estava executando 10 threads busy() em 6 núcleos [todos estavam em 100%], eu injetei as 1000 inserções na tabela, demorei um pouco mais que o normal, então

select * from a where d1 <> d2 or d1 <> d3 or d1 <> d4;
Empty set (0.00 sec)

Sim! MySQL é muito bem feito! (sério, sempre me surpreendo com a qualidade dos algoritmos e programação do sistema por trás desse SGBD).

Não, não haverá diferença

como MysQL escreve no manual

NOW() retorna uma hora constante que indica a hora em que a instrução começou a ser executada.

Este parece ser um comportamento diferente de todas as outras funções, que são executadas coluna por coluna.

CREATE TABLE mytable (id INT AUTO_INCREMENT PRIMARY KEY, Created DATETIME , Updated DATETIME)

INSERT INTO mytable (id, Created, Updated) VALUES (null, NOW(), NOW())

INSERT INTO mytable (id, Created, Updated) VALUES (null, NOW(3), NOW(3))

SELECT MICROSECOND(Created),MICROSECOND(Updated) FROM mytable

MICROSSEGUNDO(Criado) | MICROSSEGUNDO(Atualizado)
-------------------: | -------------------:
                   0 | 0
                   0 | 0

CREATE TABLE mytable2 (id INT AUTO_INCREMENT PRIMARY KEY, Created DATETIME(3) , Updated DATETIME(3))

INSERT INTO mytable2 (id, Created, Updated) VALUES (null, NOW(3), NOW(3))

SELECT MICROSECOND(Created),MICROSECOND(Updated) FROM mytable2

MICROSSEGUNDO(Criado) | MICROSSEGUNDO(Atualizado)
-------------------: | -------------------:
              186000 | 186000

db<>fique aqui