A sintaxe do SQL diferencia maiúsculas de minúsculas?

O SQL diferencia maiúsculas de minúsculas. Eu usei o MySQL e o SQL Server, que parecem ser sensíveis a maiúsculas e minúsculas. Esse sempre é o caso? O padrão define a distinção entre maiúsculas e minúsculas?

Os SQL Palavras-chave são case-insensitive ( SELECT, FROM, WHERE, etc), mas são muitas vezes escritos em todos os tampões. No entanto, em algumas configurações, os nomes de tabelas e colunas diferenciam maiúsculas de minúsculas. O MySQL possui uma opção de configuração para ativar / desativar. Geralmente, os nomes de tabela e coluna com distinção entre maiúsculas e minúsculas são o padrão no MySQL Linux e sem distinção entre maiúsculas e minúsculas costumava ser o padrão no Windows, mas agora o instalador perguntou sobre isso durante a instalação. Para o MSSQL, é uma função da configuração de agrupamento do banco de dados.

Aqui está a página do MySQL sobre diferenciação entre maiúsculas e minúsculas no nome

Aqui está o artigo no MSDN sobre agrupamentos para o MSSQL

Essa não é uma linguagem estritamente SQL, mas no SQL Server se o agrupamento do banco de dados faz distinção entre maiúsculas e minúsculas, todos os nomes de tabela diferenciam maiúsculas de minúsculas.

No Sql Server , é uma opção . Ligá-lo é uma merda.

Eu não tenho certeza sobre o MySql.

Identificadores e palavras reservadas não devem fazer distinção entre maiúsculas e minúsculas, embora muitos sigam uma convenção para usar maiúsculas para palavras reservadas e Pascal para identificadores.

Consulte SQL-92 Sec. 5.2.

A especificação SQL92 afirma que os identificadores podem ser citados ou não. Se ambos os lados não estão entre aspas, eles sempre diferenciam maiúsculas de minúsculas, por exemplo table_name == TAble_nAmE.

No entanto, os identificadores citados diferenciam maiúsculas de minúsculas, por exemplo "table_name" != "TAble_naME". Também com base nas especificações, se você deseja comparar identificadores não citados com citados, os identificadores não citados e citados podem ser considerados iguais, se os caracteres não citados estiverem em maiúsculas, por exemplo TABLE_NAME == "TABLE_NAME", mas TABLE_NAME != "table_name"ou TABLE_NAME != "TAble_NaMe".

Aqui está a parte relevante das especificações (seção 5.2.13):

     13)A <regular identifier> and a <delimited identifier> are equiva-
        lent if the <identifier body> of the <regular identifier> (with
        every letter that is a lower-case letter replaced by the equiva-
        lent upper-case letter or letters) and the <delimited identifier
        body> of the <delimited identifier> (with all occurrences of
        <quote> replaced by <quote symbol> and all occurrences of <dou-
        blequote symbol> replaced by <double quote>), considered as
        the repetition of a <character string literal> that specifies a
        <character set specification> of SQL_TEXT and an implementation-
        defined collation that is sensitive to case, compare equally
        according to the comparison rules in Subclause 8.2, "<comparison
        predicate>".

Observe que, assim como em outras partes do padrão SQL, nem todos os bancos de dados seguem esta seção completamente. O PostgreSQL, por exemplo, armazena todos os identificadores não citados em letras minúsculas em vez de maiúsculas, portanto table_name == "table_name"(exatamente o oposto do padrão). Além disso, alguns bancos de dados fazem distinção entre maiúsculas e minúsculas o tempo todo, ou a distinção entre maiúsculas e minúsculas depende de alguma configuração no banco de dados ou depende de algumas das propriedades do sistema, geralmente se o sistema de arquivos faz distinção entre maiúsculas e minúsculas.

Observe que algumas ferramentas de banco de dados podem enviar identificadores citados o tempo todo, portanto, nos casos em que você mistura consultas geradas por alguma ferramenta (como uma consulta CREATE TABLE gerada pelo Liquibase ou outra ferramenta de migração de banco de dados), com consultas feitas à mão (como uma simples seleção JDBC em seu aplicativo), você deve garantir que os casos sejam consistentes, especialmente em bancos de dados em que os identificadores entre aspas e não citados sejam diferentes (DB2, PostgreSQL, etc.)

Meu entendimento é que o padrão SQL exige distinção entre maiúsculas e minúsculas. Porém, não acredito que nenhum banco de dados siga completamente o padrão.

O MySQL possui uma configuração como parte de seu "modo estrito" (um pacote de várias configurações que tornam o MySQL mais compatível com os padrões) para nomes de tabela com distinção entre maiúsculas e minúsculas. Independentemente dessa configuração, os nomes das colunas ainda não diferenciam maiúsculas de minúsculas, embora eu pense que isso afeta a maneira como os nomes das colunas são exibidos. Acredito que essa configuração seja válida para toda a instância, em todos os bancos de dados da instância RDBMS, embora eu esteja pesquisando hoje para confirmar isso (e esperando que a resposta seja não).

Eu gosto de como a Oracle lida com isso muito melhor. No SQL direto, identificadores como nomes de tabelas e colunas não diferenciam maiúsculas de minúsculas. No entanto, se por algum motivo você realmente deseja obter uma caixa explícita, pode colocar o identificador entre aspas duplas (que são bastante diferentes no Oracle SQL das aspas simples usadas para colocar dados de sequência). Assim:

SELECT fieldName
FROM tableName;

consulta o nome do campo do nome da tabela , mas

SELECT "fieldName"
FROM "tableName";

consultará o fieldName do tableName .

Tenho certeza de que você pode usar esse mecanismo para inserir espaços ou outros caracteres não padrão em um identificador.

Nessa situação, se, por algum motivo, você achar desejável que os nomes de tabelas e colunas explicitamente explicados estejam disponíveis, você ainda deve ter cuidado com isso.

Minha convenção quando usava o Oracle diariamente era que, no código, eu colocava todas as palavras-chave do Oracle SQL em maiúsculas e todos os identificadores em minúsculas. Na documentação, eu colocaria todos os nomes de tabelas e colunas em maiúsculas. Era muito conveniente e legível poder fazer isso (embora às vezes seja difícil digitar tantas letras maiúsculas no código - tenho certeza de que poderia ter encontrado um recurso de editor para ajudar aqui).

Na minha opinião, o MySQL é particularmente ruim por diferir sobre isso em diferentes plataformas. Precisamos despejar bancos de dados no Windows e carregá-los no UNIX, e isso é um desastre se o instalador no Windows esquecer de colocar o RDBMS no modo de diferenciação de maiúsculas e minúsculas. (Para ser justo, parte do motivo desse desastre é que nossos codificadores tomaram a péssima decisão, há muito tempo, de confiar na distinção entre maiúsculas e minúsculas do MySQL no UNIX.) As pessoas que criaram o instalador do Windows MySQL o tornaram realmente conveniente e Como o Windows, e foi ótimo avançar para dar às pessoas uma caixa de seleção para dizer "Deseja ativar o modo estrito e tornar o MySQL mais compatível com os padrões?" Mas é muito conveniente para o MySQL diferir tão significativamente do padrão, e, em seguida, torne as coisas piores, revertendo e diferindo de seu próprio padrão de fato em diferentes plataformas. Tenho certeza de que em diferentes distribuições Linux isso pode ser ainda mais complexo, pois os empacotadores de diferentes distribuições provavelmente às vezes incorporaram suas próprias configurações de configuração preferidas do MySQL.

Aqui está outra questão de SO que entra em discussão se a distinção entre maiúsculas e minúsculas é desejável em um RDBMS.

Não. O MySQL não diferencia maiúsculas de minúsculas nem o padrão SQL. É apenas prática comum escrever os comandos em maiúsculas.

Agora, se você está falando sobre nomes de tabelas / colunas, sim, eles são, mas não os próprios comandos.

assim

SELECT * FROM foo;

é o mesmo que

select * from foo;

mas não é o mesmo que

select * from FOO;

Eu achei este post do blog muito útil (eu não sou o autor). Resumindo (leia, no entanto):

... identificadores delimitados diferenciam maiúsculas de minúsculas ("nome_tabela"! = "nome_tabela"), enquanto identificadores não citados não são e são transformados em maiúsculas (nome_tabela => TABLE_NAME).

Ele descobriu que o DB2, Oracle e Interbase / Firebird são 100% compatíveis:

O PostgreSQL ... coloca em minúsculas todos os identificadores não citados, em vez de em maiúsculas. MySQL ... depende do sistema de arquivos. SQLite e SQL Server ... os nomes de tabela e campo são preservados na criação, mas são completamente ignorados posteriormente.

Eu não acho que o SQL Server faz distinção entre maiúsculas e minúsculas, pelo menos não por padrão.

Quando estou consultando manualmente pelo Management Studio, eu estrago o caso o tempo todo e ele aceita alegremente:

select cOL1, col2 FrOM taBLeName WheRE ...

As palavras-chave SQL não fazem distinção entre maiúsculas e minúsculas.

Os nomes de tabelas, colunas etc. têm uma distinção entre maiúsculas e minúsculas e dependem do banco de dados - você provavelmente deve presumir que diferenciam maiúsculas de minúsculas, a menos que saiba de outra maneira (em muitos bancos de dados eles ainda não são; no MySQL, os nomes de tabelas são SOMETIMES diferencia maiúsculas de minúsculas, mas a maioria dos outros nomes não são).

A comparação de dados usando =,>, <etc, tem um reconhecimento de caso que depende das configurações de agrupamento que estão em uso no banco de dados individual, tabela ou mesmo coluna em questão. No entanto, é normal manter o agrupamento razoavelmente consistente em um banco de dados. Temos algumas colunas que precisam armazenar valores que diferenciam maiúsculas de minúsculas; eles têm um agrupamento especificamente definido.

Tenha o melhor dos dois mundos

Atualmente, você pode escrever todas as suas instruções sql em minúsculas e, se precisar formatá-las, basta instalar um plug-in que fará isso por você. Isso é aplicável apenas se o seu editor de código tiver esses plugins disponíveis. O VSCode possui muitas extensões que podem fazer isso.