A former colleague from my MySQL AB days asked me about SELECT pk, SUM(amount) AS pk FROM t ORDER BY pk; should the duplicate use of the name PK be illegal?
My reply is: A relational-database expert deplores it in the select list; the SQL standard says it’s conceptually illegal in the order-by clause; MySQL and MariaDB handle it in an odd way; the Ocelot GUI for MySQL and MariaDB doesn’t flag it.
A relational-database expert deplores
CJ.Date, in Date On Databases, Writings 2000-2006, has a multi-page section about “Duplicate Column Names”. I’ll just quote the firmest negatives.
… we can avoid the duplicate names if we want to. The problem is, we don’t have to, and SQL does not have to deal with the possibility that a given table might have column names that aren’t unique. As an aside, I should explain that … we don’t have to use the “AS column name” construct is because it wasn’t part of the original standard (it was introduced with SQL:1992), and compatibility therefore dictates that its use has to be optional. (I should also note in passing that — believe it or not — names introduced by AS don’t have to be unique!
*Every SQL table has a left-to-right column ordering *Every column in every named SQL table (i.e. base table or view) has a user-known name, and that name is unique within the table in question. But neither of these properties holds, in general, for unnamed tables (i.e. intermediate and final result tables). … I’d like to point out that duplicate and missing column names both constitute a fairly egregious violation of The Naming Principle
So nothing’s ambiguous about Mr Date’s evaluation, but he is acknowledging that SQL won’t be changing due to compatibility with old standards, and at least it wouldn’t allow duplicate column names in the select list of a CREATE VIEW statement.
The SQL standard says it might be illegal
The standard says this about Concepts:
This Clause describes concepts that are, for the most part, specified precisely in other parts of ISO/IEC 9075. In any case of discrepancy, the specification in the other part is to be presumed correct.
So we usually expect a specific syntax rule, but if it’s missing, we maybe can look at Concepts.
And this is SQL:2016, Foundation, 4.13 Columns, fields, and attributes, in the Concepts section:
Sometimes the Syntax Rules forbid two elements at different ordinal positions from having equivalent names (particularly when created through an SQL schema statement). When two elements with equivalent names are permitted, then the element name is ambiguous and attempts to reference either element by name will raise a syntax error.
That suggests that if pk appears twice in select list then ORDER BY pk; should fail, but it’s not explicitly stated in the Syntax Rules. This in contrast with GROUP BY, which has a clear Syntax Rule, that is, “Each grouping column reference shall unambiguously reference a column of the table resulting from the from clause.” Perhaps when I was on the ANSI committee I should have asked why Syntax Rule for ORDER BY doesn’t also say “unambiguously”, but it’s too late now.
MySQL and MariaDB handle it in an odd way
I tried variations of the syntax with MySQL 8.0.31 and MariaDB 10.10.1, sql_mode=only_full_group_by is not true, sql_mode=ansi_quotes is true. They both return the same results.
CREATE TABLE t (pk INT, amount INT); INSERT INTO t VALUES (1,2), (2,1),(1,2),(2,1); SELECT pk, (amount) AS pk FROM t ORDER BY pk; Result: Error 1052 (23000) Column ‘pk’ in order clause is ambiguous SQLSTATE values starting with 23 are for “integrity constraint violation”, so it would be better to have something starting with 42 (syntax error or access violation), I described good old ’42’ in an earlier blog post. However, the error message is good and consistent with standard SQL.
SELECT pk, SUM(amount) AS pk FROM t ORDER BY pk; Result: 1,6. SELECT pk, 5 AS pk, amount FROM t ORDER BY pk,amount DESC; Result: (1,5,2),(1,5,2),(2,5,1),(2,5,1) SELECT pk, (SELECT SUM(amount) AS pk FROM t) AS "pk" FROM t ORDER BY pk; Result: (1,6),(2,6),(1,6),(2,6) These results are harmless — there’s either an implied grouping or a literal for the main sort, so they’re always the same value, so they can be optimized away. Nevertheless, they’re inconsistent — if “Column ‘pk’ in order clause is ambiguous” is detectable, and it’s a syntax error not a runtime error, it shouldn’t have been ignored.
SELECT pk * - 1 AS pk, pk FROM t ORDER by pk; Result: (-2,2),(-2,2),(-1,1),(-1,1) SELECT pk, pk * - 1 AS pk FROM t ORDER by pk; Result: (2,-2),(2,-2),(1,-1),(1,-1) These results are odd, they show that we’re ordering by the pk that has an AS clause, regardless of which column is first in the select list.
SELECT SUM(amount) AS pk, pk FROM t GROUP BY pk ORDER BY pk; Result: (2,2),(4,1) Also there is a warning: Column ‘pk’ in group statement is ambiguous. But it does succeed, and once again the item with the AS clause is preferred. This syntax is explicitly declared illegal in standard SQL.
SELECT * FROM (SELECT 1 AS a, 1 AS a) AS t1, (SELECT 1 AS a, 1 AS a) AS t2; Result: Error 1060 (42S21) Duplicate column name ‘a’ This is the right result, and the SQLSTATE is better because it starts with ’42’. The reason it’s correct is that Trudy Pelzer long ago reported a bug with duplicate names in subqueries, which are illegal due to a different item in the standard, and Oleksandr Byelkin fixed it.
The Ocelot GUI for MySQL and MariaDB doesn’t flag it
An obvious thought is: since ocelotgui recognizes MySQL/MariaDB syntax, and gives hints or autocompletions while the user is entering a statement, should I be adding code to catch this? After all, we stop most illegal syntax before it goes to the server.
But I’m wary. The behaviour that I describe here is undocumented, so it could change without warning, and besides who are we to reject what the server would accept? It won’t be at the top of the “To Do” pile.
Speaking of “To Do” piles, ocelotgui 1.8 has now been released, and is downloadable from github.
A while ago we got a question about data type conversion and SQLSTATE …
“ Suppose we have data types T1 and T2 (either built-in or user defined).
This pair is not explicitly listed in the Store Assignment rules.
There is no a CREATE CAST for this pair defined.
Reading the standard, I have an impression that these statements should fail:
UPDATE t1 SET T1_col=T2_col; INSERT INTO t1 (T1_col) SELECT T2_col FROM t1; SET T1_var=T2_var; — inside an SP
But I could not find which exactly error should be raised:
what should be SQLSTATE
what should be error message text
A related question: Is it possible to do CREATE CAST for a pair of two built-in data types? “
The answer was …
I will be quoting 9075-1:2011 Framework and 9075-2:2016 Foundation.
Framework says: “In the Syntax Rules, the term shall defines conditions that are required to be true of syntactically conforming SQL language. When such conditions depend on the contents of one or more schemas, they are required to be true just before the actions specified by the General Rules are performed. The treatment of language that does not conform to the SQL Formats and Syntax Rules is implementation-dependent. If any condition required by Syntax Rules is not satisfied when the evaluation of Access or General Rules is attempted and the implementation is neither processing non-conforming SQL language nor processing conforming SQL language in a non-conforming manner, then an exception condition is raised: syntax error or access rule violation.” … Therefore: if you see the word “shall” in a syntax rule, and the condition is not true, it is a syntax error or access violation.
Foundation says: re set clause list: “Otherwise, the Syntax Rules of Subclause 9.2, “Store assignment”, are applied with the column of T identified by the <object column> as TARGET and the <update source> of the <set clause> as VALUE.”
Foundation says: re store assignment: syntax rules: where SD = source data type and TD = target data type: “If TD is character string, binary string, numeric, boolean, datetime, interval, or a user-defined type, then either SD shall be assignable to TD or there shall exist an appropriate user-defined cast function UDCF from SD to TD.” … Therefore: since the word “shall” has been used and this is a syntax rule: if the condition is not true, it is a syntax error or access violation.
Foundation says: re definition of assignable: “A binary string is assignable only to sites of binary string type.” “A number is assignable only to sites of numeric type.” … And so on. That is, for each data type, there’s a note about what assignable means for that type. Now take this as an example: … SET binary_string_target = numeric_source … According to “A binary string is assignable only to sites of binary string type”, this SD is not assignable to this TD. Therefore, unless there is an appropriate user-defined cast function, the partial condition “SD shall be assignable to TD” has not been met.
For a moment ignore the other partial condition, “there shall exist an appropriate user-defined cast function”. In that case, now we know that the rule for store assignment, which is required by the rule for set clause list, has not been met. And that rule is a syntax rule that includes the word “shall”. So it is a syntax error or access rule violation. Table 38 “SQLSTATE class and subclass codes” says that the class for syntax error or access rule violation is 42. Thus it’s clear — at last, eh? — that the SQLSTATE class is 42. What about the subclass? Foundation says: “NOTE 767 — One consequence of this is that an SQL-implementation may, but is not required by ISO/IEC 9075 to, provide subclasses for exception condition syntax error or access rule violation that distinguish between the syntax error and access rule violation cases.” In other words, you can say SQLSTATE is 42000 but you can say other things too. Here I recommend that you look at what DB2 for z/OS has.
“42806 A value cannot be assigned to a variable, because the data types are not compatible.” or “42821 A data type for an assignment to a column or variable is not compatible with the data type.”
Conclusion: the SQLSTATE can be 42xxx, e.g. 42821, syntax error or access violation.
But there are two loopholes! Long ago, when my job was to say how MySQL was compatible with standard SQL, I used them both.
Loophole #1: See above: “The treatment of language that does not conform to the SQL Formats and Syntax Rules is implementation-dependent.” Well, whenever MySQL/MariaDB has a type that is not mentioned in the official rules, such as TEXT rather than CHARACTER VARYING, that means you can declare there is no error.
Loophole #2: See above: “or there shall exist an appropriate user-defined cast function”. Well, there is a cast function whenever MySQL/MariaDB says there is. That is, if Monty declares that you can assign a number to a varchar, while smiling, I would explain: the meaning of the word “user” is implementation-dependent. In this case, the user who created the function is Monty. That means you can declare there is no error.
But, if you declare that you are using the loopholes, then CREATE CAST will be illegal because Foundation requires: “There shall be no user-defined cast for SDT and TDT.” and, alas, where user = Monty, there is a user-defined cast.
Thanks to Alexander Barkov for the question.
ocelotgui explorer
On an unrelated note, the Ocelot Graphical User Interface has an explorer.
Sometimes called a navigator, and vaguely like what people are used to with Windows Explorer, this is a widget that appears (usually on the left but detachable) showing objects in all schemas that the user can access. If the user right-clicks on an object, an in-context menu appears with SQL statements or client actions that can be performed by clicking. Customizable.
Currently it’s only in source code which you can download from github, as always.
It and its documentation will be in the next release and/or in the next post of this blog.
Bug fix: due to a recent MariaDB change, our stored-procedure debugger could not be installed when connecting to a MariaDB server (MySQL debugging was not affected). Now all is well again.
Here, for example, is a screenshot of ocelotgui after connecting to MariaDB 10.8, saying $debug P; and then Alt+5 (“Step”) 4 times, then clicking menu item “Refresh user variables” to see the previous and current values of @a:
/
Incidentally I’ve just noticed some old comments about ocelotgui on https://stackoverflow.com/questions/3007625/mysql-stored-procedure-debugging with one user saying “… helped me a lot!” and another saying “I connected, debugged their tutorial, and am amazed. it’s a GREAT step debugger with variable data view on demand. lots to learn, but the #1 choice so far for free.” Don’t get the wrong idea though — debugging is a unique feature but not the major one.
New platform: Actually ocelotgui runs on any Linux distro (and Windows of course); however, the only specific instructions for creating packages were ones for .deb (Debian-based) and .rpm (Red-Hat-based). Now there is a script file for creating packages on Arch-Linux-based distros too, for example Manjaro or EndeavourOS. It’s PKGBUILD.
Enhancement: Detaching wasn’t quite as spiffy as it should be because our size calculations were slightly wrong. Here’s a screenshot showing the same widgets as before, after detaching them all and doing some manual fiddling:
I’ll cover SUBSTRING’s variants, its behaviour in odd cases, and what can go wrong. I’ll add a C program that emulates what the SQL:2016 standard requires.
Ordinary case
SUBSTRING(value-expression FROM start-position [FOR string-length])
I expect that everyone knows the ordinary case: value-expression should be either a character string or a binary string, start-position and string-length should be integers, and SUBSTRING(‘abc’ FROM 2 FOR 2) will return ‘bc’.
Abbreviating SUBSTRING to SUBSTR, with commas instead of words to separate arguments, is Oracle and SQLite syntax. MySQL cheerily accepts both syntaxes and treats them as synonyms.
Informix accepts both but does not treat them as synonyms. DB2 has something similar.
So when you have a choice, you just have to decide: do you want to be compatible with Oracle, or with almost everybody else?
Variation: passing a non-string and non-integers
In MySQL/MariaDB I can say SUBSTRING(123, 1.5, 1.1) and get ‘2’. The standard requirement is: the first argument must be a string and the others must be exact with scale 0. So rather than accepting decimals and rounding, others will call this an error.
What we’re seeing here is the typical MySQL/MariaDB idea that, if it’s possible to do something with the input, do it. And in this case it’s possible by converting the first argument to a string and rounding the next arguments.
But it’s not a strictly MySQL thing, Oracle and DB2 will also accept non-integers and do implicit conversions.
Variation: negative start-position
This is probably the most frequent variation.
What is SUBSTRING(‘abc’, -2, 2)?
The standard is 100% clear (well, as clear as it ever gets): start-position is 2 characters before the start of the string, and string start is 1, so SUBSTRING(‘abc’ FROM -2 FOR 2) is a zero-length string but SUBSTRING(‘abc’ FROM -2 FOR 4) is ‘a’. SQL Server follows this though I don’t know whether it always does so.
However — perhaps because programmers are used to seeing such stuff in php and perl and Lua — the alternative is to say that negative start-positions are counted backwards from the end of the string, so -1 is the last character, -2 is the second-last, and so on.
So in MySQL SUBSTRING(‘abc’ FROM -2 FOR 2) is ‘bc’ and SUBSTRING(‘abc’ FROM -2 FOR 4) is also ‘bc’. But don’t hope for consistency: SUBSTRING(‘abc’ FROM -4 FOR 5) is just a zero-length string.
I’ll admit that the count-backwards variation is popular, since it’s in Oracle and SQLite and MySQL/MariaDB (and in Informix SUBSTR, which is the difference I mentioned earlier). But it’s awfully easy to avoid: use a different function if your DBMS supports RIGHT() or INSTR(), or say SUBSTRING(‘abc’ FROM LENGTH(‘abc’) – 2 FOR 2).
For that last suggestion, I wondered: won’t that take longer? So I filled a table with long strings.
CREATE TABLE j (s1 TEXT(1000000));
CREATE PROCEDURE p()
BEGIN
DECLARE i INTEGER DEFAULT 0;
WHILE i < 737 DO
INSERT INTO j VALUES (REPEAT('abc',1000000));
SET i = i + 1;
END WHILE;
END;
CALL p();
SELECT SUBSTRING(s1 FROM -2 FOR 2) FROM j;
SELECT SUBSTRING(s1 FROM LENGTH(s1)-2 FOR 2) FROM j;
The SELECT with “FROM -2” takes on average about 12 seconds on my laptop. The SELECT with “FROM LENGTH(s1)-2” takes on average about 7 seconds. Your mileage will vary but if you get anything vaguely similar you’ll have to conclude that non-standard negative start positions are unnecessary.
Variation: going past the end
Of course SUBSTRING(‘abc’ FROM 3 FOR 5) is ‘c’ and the nonexistent characters past the end don’t matter. That’s standard, and it’s why I found it inconsistent when I saw different behaviour for nonexistent characters before the start.
But there’s another possible answer: the DB2 incomprehensible result. The documentation for SUBSTR() says that the result is an error, and simultaneously that the string is padded on the right with spaces or zero bytes.
Variation: CHAR in, VARCHAR out
If the input is CHAR, is the result supposed to be CHAR?
The standard is once again clear about this: “If the declared type of <character value expression> is fixed-length character string or variable-length character string, then DTCSF is a variable-length character string type with maximum length equal to the fixed length or maximum length of DTCVE.”
For Oracle the result is VARCHAR if the input is CHAR.
For SQL Server the result is VARCHAR if the input is CHAR.
For DB2 the result is VARCHAR if the input is CHAR.
For MySQL the result is undocumented so I used my usual way of finding out what the data type of a result is …
CREATE TABLE j (s1 CHAR(5));
CREATE TABLE j2 AS SELECT SUBSTRING(s1 FROM 2 FOR 2) FROM j;
SELECT table_name, data_type FROM information_Schema.columns WHERE column_name = 's1';
Result: ‘char’. Yes, I know, SHOW CREATE TABLE j2; would say ‘varchar’, but I don’t rely on it here. If you set sql_mode=’pad_char_to_full_length’; and then select length(column_name) from all rows in the table, you’ll see it’s always the defined length.
Variation: octets
SUBSTRING(… FROM … FOR … [USING CHARACTERS|OCTETS])
By now you’ve gathered that my main concern is SUBSTRING for characters more than SUBSTRING for binaries, but the standard says I can specify the position and length in bytes rather than characters.
So, if you’ve got a multi-byte character, and you use OCTETS, you can split it so that the result is not valid characters. For example: starting with ‘Д’ in UTF-8 (which is encoded as 0D94): SUBSTRING(‘Д’ FROM 2 FOR 1 USING OCTETS) is X’94’ which is not a UTF-8 character that was in the input.
DB2 covers this up by replacing invalid character fragments with spaces.
For the standard, for the newer substring function added in SQL:2016, I read: “If [character length units] is OCTETS and the [relevant] octet of STR is not the first octet of a character, then the result of [this function] is implementation-dependent.” That certainly seems like the appropriate thing to say about all substring functions.
Variation: added in SQL:2016
These SUBSTRING syntaxes which are part of SQL:2016 might someday be interesting:
<regular expression substring function> ::=
SUBSTRING <left paren> <character value expression> SIMILAR <character value expression>
ESCAPE <escape character> <right paren>
<regex substring function> ::=
SUBSTRING_REGEX <left paren>
<XQuery pattern> [ FLAG <XQuery option flag> ]
IN <regex subject string>
[ FROM <start position> ]
[ USING <char length units> ]
[ OCCURRENCE <regex occurrence> ]
[ GROUP <regex capture group> ]
<right paren>
… but as of today they seem to have not caught fire in popular imagination.
Variation: zero-length strings can be errors
The obsolete manual for Oracle 10g says “When you specify a value that is less than 1, the function returns NA.” which I guess means it was an error long ago. Now the return is null because Oracle doesn’t distinguish it from a zero-length string.
In a draft of an earlier SQL standard, one might read: “16) If the result of <string value expression> is a zero-length character string, then it is implementation-defined whether an exception condition is raised: data exception — zero-length character string”
But that, in the section about <string value function>, didn’t fit well. It was replaced by “16) If the result of <string value function> is the zero-length character string or the zero-length binary string, then it is implementation-defined whether an exception condition is raised: data exception – zero-length character string or data exception – zero-length binary string, respectively.”
So: if the result of SUBSTRING() is ”, then it’s not a violation of the standard to return an error. However, I don’t expect that anybody would say that unless they did the same for everything, not just SUBSTRING().
C program that does what the standard says
I said the standard document is clear, but it is also intimidating. The main clause about SUBSTRING for characters looks like this:
3)If <character substring function> is specified, then:
a) If the character encoding form of <character value expression> is UTF8, UTF16, or UTF32, then, in
the remainder of this General Rule, the term "character" shall be taken to mean "unit specified by
<char length units>".
b) Let C be the value of the <character value expression>, let LC be the length in characters of C, and
let S be the value of the <start position>.
c) If <string length> is specified, then let L be the value of <string length> and let E be S+L. Otherwise,
let E be the larger of LC + 1 and S.
d) If at least one of C, S, and L is the null value, then the result of the <character substring function> is
the null value.
e) If E is less than S, then an exception condition is raised: data exception - substring error.
f) Case:
i) If S is greater than LC or if E is less than 1 (one), then the result of the <character substring
function> is the zero-length character string.
ii) Otherwise,
1) Let S1 be the larger of S and 1 (one). Let E1 be the smaller of E and LC+1. Let L1 be
E1-S1.
2) The result of the <character substring function> is a character string containing the L1
characters of C starting at character number S1 in the same order that the characters appear
in C.
It’s not something that humans can grasp immediately. But notice that, in English, it’s declaring variables and conditional-execution statements. So for testing purposes it’s straightforward to convert the English into C. That’s what I’ve done for this section. Here is a stand-alone program that replicates all the important parts of the clause so that anyone can see what SUBSTRING() would produce for any combination of SUBSTRING(value-expression FROM start-position [FOR string-length])
/*
Simulate ISO 9075-2:2016 description of substring
By Peter Gulutzan 2021-08-30
Copyright (c) 2021 by Peter Gulutzan. All rights reserved.
To compile: gcc -o substring substring.c
To run, with 2 or 3 args: substring character_value_expression start_position [string_length]
Assumption: start_position and string_length are integers, there is no validity check.
Convention: if character_value_expression is - then we treat it as an empty string.
Example:
pgulutzan@pgulutzan-VirtualBox:~/tarantool_sandbox$ ./substring 'abc' -1 1
character_value_expression: abc.
start_position: -1
string_length: 1
LC: 3
S: -1
L: 1
E: 0
S > LC or E < 1. Return zero-length string
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
int main( int argc, char *argv[] )
{
if ((argc < 3) || (argc > 4))
{
printf("We want: character_value_expression start_position string_length\n");
exit(0);
}
bool is_length_specified;
char *character_value_expression= argv[1];
int start_position= atoi(argv[2]); /* no validity check */
int string_length;
if (argc == 3)
{
is_length_specified= false;
}
else
{
is_length_specified= true;
string_length= atoi(argv[3]); /* no validity check */
}
printf("character_value_expression: %s.\n", character_value_expression);
printf("start_position: %d\n", start_position);
if (is_length_specified == false)
{
printf("string_length: not specified\n");
}
else
{
printf("string_length: %d\n", string_length);
}
char *C= character_value_expression;
int LC= -99, S= -99, E= -99, L= -99, S1= -99, E1= -99, L1= -99;
if (strcmp(character_value_expression, "-") == 0) LC= 0;
else LC= strlen(C);
printf("LC: %d\n", LC);
S= start_position;
/* c) If <string length> is specified, then let L be the value of <string length> and let E be S+L. Otherwise,
let E be the larger of LC + 1 and S. */
if (is_length_specified == true)
{
L = string_length;
E= S + L;
}
else
{
if ((LC + 1) > S) E= LC + 1;
else E= S;
}
printf("S: %d\n", S);
printf("L: %d\n", L);
printf("E: %d\n", E);
/* e) If E is less than S, then an exception condition is raised: data exception -- substring error. */
if (E < S)
{
printf("E < S. data exception -- substring error.\n");
exit(0);
}
/* f) i) If S is greater than LC or if E is less than 1 (one), then the result of the <character substring
function> is the zero-length character string. */
if ((S > LC) || (E < 1))
{
printf("S > LC or E < 1. Return zero-length string\n");
exit(0);
}
/* f) ii) 1) Let S1 be the larger of S and 1 (one). Let E1 be the smaller of E and LC+1. Let L1 be
E1-S1. */
if (S > 1) S1= S;
else S1= 1;
if (E < (LC + 1)) E1= E;
else E1= LC + 1;
L1= E1 - S1;
printf("S1: %d\n", S1);
printf("E1: %d\n", E1);
printf("L1: %d\n", L1);
/* f) ii) 2 The result of the <character substring function> is a character string containing the L1
characters of C starting at character number S1 in the same order that the characters appear
in C. */
for (int i= S1 - 1; i < (S1 - 1) + L1; ++i)
{
printf("%c\n", *(C + i));
}
}
ocelotgui progress
The open-source GUI client program is getting constantly better. The next big feature will be “Export” to a variety of formats including delimited, boxed, html, and default. The preliminary code has been uploaded to our github repository.
The README for the current version (1.5) is here for MySQL/MariaDB. Or, here for Tarantool.
A while ago I noticed a forum with tips for changing the colour of some results of the mysql utility. They’re nifty but tricky and don’t look appropriate for ordinary users. So I’ll concentrate on what a GUI can do instead. I illustrate with ocelotgui but any good product should be similar.
My example table is
CREATE TABLE elements (atomic_number INTEGER PRIMARY KEY, name VARCHAR(20));
INSERT INTO elements VALUES
(48,'Cadmium'),(20,'Calcium'),(98,'Californium'),(6,'Carbon'),(58,'Cerium'),
(55,'Cesium'),(17,'Chlorine'),(24,'Chromium'),
(27,'Cobalt'),(112,'Copernicium'),(29,'Copper'),(96,'Curium');
Obvious and simple things with a Settings menu
Of course there will be a menu item for Settings that puts up a dialog box.
The important items on it will be for changing background colour and font. For example these three displays show what happens after the settings menu has changed background colours and fonts.
I prefer to use the dialog box initially and then make the changes
permanent with client statements or startup options.
HTML in the select list
HTML is designed for people who want to customize colours and fonts, and many SQL users are familiar with it, so it’s natural to want it for changing colours and fonts in an SQL result set.
For example, with a WHEN trick, here we display a column as bold, or as italic, depending on the value:
SELECT CASE
WHEN name LIKE '%ium' THEN '<b>' || name || '</i>'
ELSE '<i>' || name || '</i>'
END
AS name,
atomic_number
FROM elements;
For example, with a UNION trick, here we display in red or in blue, depending on the value:
SELECT
'<p style="color:red">' ||
CAST(atomic_number AS VARCHAR(20)) AS atomic_number,
'<p style="color:red">' || name AS name
FROM elements
WHERE atomic_number < 90
UNION ALL
SELECT atomic_number,
'<p style="color:blue">' || name AS name
FROM elements
WHERE atomic_number >= 90;
You could accomplish the same effects with REPLACE() or with stored procedures. An obvious usage is for emphasizing NULLs which otherwise are hard to distinguish from blanks. The advantage of this technique is that, even if your GUI isn’t this sophisticated, you can still get the effect by piping the result set to a file where a browser can read it. The distadvantages of this technique are: (a) it’s forcing the server to do a client job, (b) the column might contain ‘<‘ or ‘>’ or other entities, (c) some data types won’t work with the || concatenate operator (or the CONCAT function). So it’s best to have it as a non-default option (and that’s what the “HTML effects” option is for, on the first screenshot that I showed for Settings menu).
Conditional settings
The more general technique is to use a separate instruction for the setting, that will apply for all result sets, for cells that have certain characteristics. This is a bit like using cascading style sheets rather than inline HTML, but the best syntax is SQL-like, since that’s the language that users are bound to know. For example here is an instruction that changes a cell’s background colour and height if certain conditions are met (REGEXP means “regular expression”) (“SET ocelot_…” is a client-side statement that won’t get passed to the server):
SET ocelot_grid_background_color='yellow',
ocelot_grid_cell_height=40
WHERE column_name REGEXP 'number'
AND row_number <> 4 ;
SELECT * FROM elements LIMIT 6;
Images
Here is a cheap bar graph:
SELECT atomic_number,
SUBSTR('------------',1, atomic_number / 10) AS bar,
name
FROM elements;
MySQL/MariaDB users might prefer REPEAT(‘a’,atomic_number / 10) AS bar instead of SUBSTR. Unicode-character-set users might prefer Unicode 2588 █ (full block) instead of ‘-‘, to get a solid bar,
or might prefer a series of emojis.
Every good GUI can display .png of .jpg images too, so it’s not particularly hard to store them in the database and add them to the result via joins or subqueries. For example, with thanks to Wikipedia for the original picture,
SELECT atomic_number,
name,
(SELECT png
FROM "timages"
WHERE caption = 'copper')
AS png
FROM elements
WHERE name = 'copper';
but I hesitate to say that .png and .jpg images make good decoration, because they are never small.
ocelotgui 1.5.0
To be specific: the examples were all done with ocelotgui 1.5.0 and I used the options|detach menu choices so I could show only the select and grid widgets in a left-to-right order. Some of the functionality, particularly the new layout of the settings menu, is new. As always, the release is available on github.
This is a remake of the 2017 “Reserved words” blog post.
I have updated the lists and the news, and uploaded the source code to a GitHub repository.
In the 1990s C.J.Date said: “The rule by which it is determined within the standard that one key word needs to be reserved while another need not be is not clear to this writer.”
Nothing has changed since then, except there are more reserved words. No DBMS uses the standard list. So I think that it is probably best to know what words are reserved in product X that are not reserved in product Y. If you know, you can avoid syntax errors when you update or migrate.
I’ll present several comparisons, ending with a grand chart of all the reserved words in the standard and six current DBMSs.
First here’s a screenshot of ocelotgui where I’m hovering over the word BEGIN.
What I’m illustrating is that you can’t depend on intuition and assume BEGIN is reserved, but a GUI client can tell you from context: it’s a declared variable.
16 words are reserved in MariaDB but not in MySQL:
6 words are reserved in all of (DB2 and Oracle and Microsoft) but not in (MySQL or MariaDB):
+---------+
| word |
+---------+
| ANY |
| CURRENT |
| FILE |
| PUBLIC |
| USER |
| VIEW |
+---------+
We said in SQL-99 Complete, Really: “[The standard] suggests that you include either a digit or an underline character in your regular identifiers and avoid names that begin with CURRENT_, SESSION_, SYSTEM_, or TIMEZONE_ and those that end with _LENGTH to avoid conflicts with reserved keywords added in future revisions.” It’s also good to avoid words that begin with SYS, or words that begin with the product name such as “IBM…” or “sql…”. And of course it might also be good to use “delimiters”, if you can avoid case-sensitivity confusions.
My original reason for making lists was to answer some questions about Tarantool. I do some paid work for this group, including tutorials about SQL like this one. In a post The Tarantool SQL alpha I showed why I believe that this product is far ahead of the others that I discussed in an earlier post, What’s in the SQL of NoSQL and even has some useful characteristics that MySQL/MariaDB lack. Since then it has become GA.
News about ocelotgui: on 2021-02-09 we uploaded version 1.3. As always the executables for Linux and Windows, and the source, are in the ocelotui GitHub repository.
There is a separate README for Tarantool on the ocelotgui-tarantool GitHub repository.
There is a major fix due to a behaviour change in the latest MariaDB/MySQL versions which caused connection failure when secure_auth=1.
There is a major new feature for conditional settings of grid cells, for example you can say that the text colour will be brown and the background colour will be pink where column_name = x or row_number >= y and value regexp z.
To end this post, here is the grand finale list — all reserved words in all dialects. Sta = Standard, Mar = MariaDB, MyS = MySQL, Db2 = DB2, Ora = Oracle, Mic = Microsoft, Odb = Odbc, Tar = Tarantool. (The Mic and Odb columns represent what Microsoft recommends but doesn’t always enforce.) (The Tar column is still subject to change.)
tarantool>SELECT * FROM finale ORDER BY word;
OK 822 rows selected (0.0 seconds)
+----------------------------------+-----+-----+-----+-----+-----+-----+-----+-----+
| WORD | Sta | Mar | MyS | Db2 | Ora | Mic | Odb | Tar |
+----------------------------------+-----+-----+-----+-----+-----+-----+-----+-----+
| ABS | x | | | | | | | |
| ABSOLUTE | | | | | | | x | |
| ACCESS | | | | | x | | | |
| ACCESSIBLE | | x | x | | | | | |
| ACOS | x | | | | | | | |
| ACTION | | | | | | | x | |
| ACTIVATE | | | | x | | | | |
| ADA | | | | | | | x | |
| ADD | | x | x | x | x | x | x | |
| AFTER | | | | x | | | | |
| ALIAS | | | | x | | | | |
| ALL | x | x | x | x | x | x | x | x |
| ALLOCATE | x | | | x | | | x | |
| ALLOW | | | | x | | | | |
| ALTER | x | x | x | x | x | x | x | x |
| ANALYZE | | x | x | | | | | x |
| AND | x | x | x | x | x | x | x | x |
| ANY | x | | | x | x | x | x | x |
| ARE | x | | | | | | x | |
| ARRAY | x | | | | | | | |
| ARRAY_AGG | x | | | | | | | |
| ARRAY_MAX_CARDINALITY | x | | | | | | | |
| AS | x | x | x | x | x | x | x | x |
| ASC | | x | x | | x | x | x | x |
| ASENSITIVE | x | x | x | x | | | | x |
| ASIN | x | | | | | | | |
| ASSERTION | | | | | | | x | |
| ASSOCIATE | | | | x | | | | |
| ASUTIME | | | | x | | | | |
| ASYMMETRIC | x | | | | | | | |
| AT | x | | | x | | | x | |
| ATAN | x | | | | | | | |
| ATOMIC | x | | | | | | | |
| ATTRIBUTES | | | | x | | | | |
| AUDIT | | | | x | x | | | |
| AUTHORIZATION | x | | | x | | x | x | |
| AUTOINCREMENT | | | | | | | | x |
| AUX | | | | x | | | | |
| AUXILIARY | | | | x | | | | |
| AVG | x | | | | | | x | |
| BACKUP | | | | | | x | | |
| BEFORE | | x | x | x | | | | |
| BEGIN | x | | | x | | x | x | x |
| BEGIN_FRAME | x | | | | | | | |
| BEGIN_PARTITION | x | | | | | | | |
| BETWEEN | x | x | x | x | x | x | x | x |
| BIGINT | x | x | x | | | | | |
| BINARY | x | x | x | x | | | | x |
| BIT | | | | | | | x | |
| BIT_LENGTH | | | | | | | x | |
| BLOB | x | x | x | | | | | x |
| BOOL | | | | | | | | x |
| BOOLEAN | x | | | | | | | x |
| BOTH | x | x | x | | | | x | x |
| BREAK | | | | | | x | | |
| BROWSE | | | | | | x | | |
| BUFFERPOOL | | | | x | | | | |
| BULK | | | | | | x | | |
| BY | x | x | x | x | x | x | x | x |
| CACHE | | | | x | | | | |
| CALL | x | x | x | x | | | | x |
| CALLED | x | | | x | | | | |
| CAPTURE | | | | x | | | | |
| CARDINALITY | x | | | x | | | | |
| CASCADE | | x | x | | | x | x | |
| CASCADED | x | | | x | | | x | |
| CASE | x | x | x | x | | x | x | x |
| CAST | x | | | x | | | x | x |
| CATALOG | | | | | | | x | |
| CCSID | | | | x | | | | |
| CEIL | x | | | | | | | |
| CEILING | x | | | | | | | |
| CHANGE | | x | x | | | | | |
| CHAR | x | x | x | x | x | | x | x |
| CHARACTER | x | x | x | x | | | x | x |
| CHARACTER_LENGTH | x | | | | | | x | |
| CHAR_LENGTH | x | | | | | | x | |
| CHECK | x | x | x | x | x | x | x | x |
| CHECKPOINT | | | | | | x | | |
| CLASSIFIER | x | | | | | | | |
| CLOB | x | | | | | | | |
| CLONE | | | | x | | | | |
| CLOSE | x | | | x | | x | x | |
| CLUSTER | | | | x | x | | | |
| CLUSTERED | | | | | | x | | |
| COALESCE | x | | | | | x | x | |
| COLLATE | x | x | x | | | x | x | x |
| COLLATION | | | | | | | x | |
| COLLECT | x | | | | | | | |
| COLLECTION | | | | x | | | | |
| COLLID | | | | x | | | | |
| COLUMN | x | x | x | x | x | x | x | x |
| COLUMN_VALUE | | | | | x | | | |
| COMMENT | | | | x | x | | | |
| COMMIT | x | | | x | | x | x | x |
| COMPRESS | | | | | x | | | |
| COMPUTE | | | | | | x | | |
| CONCAT | | | | x | | | | |
| CONDITION | x | x | x | x | | | | x |
| CONNECT | x | | | x | x | | x | x |
| CONNECTION | | | | x | | | x | |
| CONSTRAINT | x | x | x | x | | x | x | x |
| CONSTRAINTS | | | | | | | x | |
| CONTAINS | x | | | x | | x | | |
| CONTAINSTABLE | | | | | | x | | |
| CONTINUE | | x | x | x | | x | x | |
| CONVERT | x | x | x | | | x | x | |
| COPY | x | | | | | | | |
| CORR | x | | | | | | | |
| CORRESPONDING | x | | | | | | x | |
| COS | x | | | | | | | |
| COSH | x | | | | | | | |
| COUNT | x | | | x | | | x | |
| COUNT_BIG | | | | x | | | | |
| COVAR_POP | x | | | | | | | |
| COVAR_SAMP | x | | | | | | | |
| CREATE | x | x | x | x | x | x | x | x |
| CROSS | x | x | x | x | | x | x | x |
| CUBE | x | | x | | | | | |
| CUME_DIST | x | | x | | | | | |
| CURRENT | x | | | x | x | x | x | x |
| CURRENT_CATALOG | x | | | | | | | |
| CURRENT_DATE | x | x | x | x | | x | x | x |
| CURRENT_DEFAULT_TRANSFORM_GROUP | x | | | | | | | |
| CURRENT_LC_CTYPE | | | | x | | | | |
| CURRENT_PATH | x | | | x | | | | |
| CURRENT_ROLE | x | x | | | | | | |
| CURRENT_ROW | x | | | | | | | |
| CURRENT_SCHEMA | x | | | x | | | | |
| CURRENT_SERVER | | | | x | | | | |
| CURRENT_TIME | x | x | x | x | | x | x | x |
| CURRENT_TIMESTAMP | x | x | x | x | | x | x | x |
| CURRENT_TIMEZONE | | | | x | | | | |
| CURRENT_TRANSFORM_GROUP_FOR_TYPE | x | | | | | | | |
| CURRENT_USER | x | x | x | x | | x | x | x |
| CURSOR | x | x | x | x | | x | x | x |
| CYCLE | x | | | x | | | | |
| DATA | | | | x | | | | |
| DATABASE | | x | x | x | | x | | |
| DATABASES | | x | x | | | | | |
| DATAPARTITIONNAME | | | | x | | | | |
| DATAPARTITIONNUM | | | | x | | | | |
| DATE | x | | | x | x | | x | x |
| DATETIME | | | | | | | | x |
| DAY | x | | | x | | | x | |
| DAYS | | | | x | | | | |
| DAY_HOUR | | x | x | | | | | |
| DAY_MICROSECOND | | x | x | | | | | |
| DAY_MINUTE | | x | x | | | | | |
| DAY_SECOND | | x | x | | | | | |
| DB2GENERAL | | | | x | | | | |
| DB2GENRL | | | | x | | | | |
| DB2SQL | | | | x | | | | |
| DBCC | | | | | | x | | |
| DBINFO | | | | x | | | | |
| DBPARTITIONNAME | | | | x | | | | |
| DBPARTITIONNUM | | | | x | | | | |
| DEALLOCATE | x | | | x | | x | x | |
| DEC | x | x | x | | | | x | |
| DECFLOAT | x | | | | | | | |
| DECIMAL | x | x | x | | x | | x | x |
| DECLARE | x | x | x | x | | x | x | x |
| DEFAULT | x | x | x | x | x | x | x | x |
| DEFAULTS | | | | x | | | | |
| DEFERRABLE | | | | | | | x | x |
| DEFERRED | | | | | | | x | |
| DEFINE | x | | | | | | | |
| DEFINITION | | | | x | | | | |
| DELAYED | | x | x | | | | | |
| DELETE | x | x | x | x | x | x | x | x |
| DENSERANK | | | | x | | | | |
| DENSE_RANK | x | | x | x | | | | x |
| DENY | | | | | | x | | |
| DEREF | x | | | | | | | |
| DESC | | x | x | | x | x | x | x |
| DESCRIBE | x | x | x | x | | | x | x |
| DESCRIPTOR | | | | x | | | x | |
| DETERMINISTIC | x | x | x | x | | | | x |
| DIAGNOSTICS | | | | x | | | x | |
| DISABLE | | | | x | | | | |
| DISALLOW | | | | x | | | | |
| DISCONNECT | x | | | x | | | x | |
| DISK | | | | | | x | | |
| DISTINCT | x | x | x | x | x | x | x | x |
| DISTINCTROW | | x | x | | | | | |
| DISTRIBUTED | | | | | | x | | |
| DIV | | x | x | | | | | |
| DO | | | | x | | | | |
| DOCUMENT | | | | x | | | | |
| DOMAIN | | | | | | | x | |
| DOUBLE | x | x | x | x | | x | x | x |
| DO_DOMAIN_IDS | | x | | | | | | |
| DROP | x | x | x | x | x | x | x | x |
| DSSIZE | | | | x | | | | |
| DUAL | | x | x | | | | | |
| DUMP | | | | | | x | | |
| DYNAMIC | x | | | x | | | | |
| EACH | x | x | x | x | | | | x |
| EDITPROC | | | | x | | | | |
| ELEMENT | x | | | | | | | |
| ELSE | x | x | x | x | x | x | x | x |
| ELSEIF | | x | x | x | | | | x |
| EMPTY | x | | x | | | | | |
| ENABLE | | | | x | | | | |
| ENCLOSED | | x | x | | | | | |
| ENCODING | | | | x | | | | |
| ENCRYPTION | | | | x | | | | |
| END | x | | | x | | x | x | x |
| END-EXEC | x | | | x | | | x | |
| ENDING | | | | x | | | | |
| END_FRAME | x | | | | | | | |
| END_PARTITION | x | | | | | | | |
| EQUALS | x | | | | | | | |
| ERASE | | | | x | | | | |
| ERRLVL | | | | | | x | | |
| ESCAPE | x | | | x | | x | x | x |
| ESCAPED | | x | x | | | | | |
| EVERY | x | | | x | | | | |
| EXCEPT | x | x | x | x | | x | x | x |
| EXCEPTION | | | | x | | | x | |
| EXCLUDING | | | | x | | | | |
| EXCLUSIVE | | | | x | x | | | |
| EXEC | x | | | | | x | x | |
| EXECUTE | x | | | x | | x | x | |
| EXISTS | x | x | x | x | x | x | x | x |
| EXIT | | x | x | x | | x | | |
| EXP | x | | | | | | | |
| EXPLAIN | | x | x | x | | | | x |
| EXTENDED | | | | x | | | | |
| EXTERNAL | x | | | x | | x | x | |
| EXTRACT | x | | | x | | | x | |
| FALSE | x | x | x | | | | x | x |
| FENCED | | | | x | | | | |
| FETCH | x | x | x | x | | x | x | x |
| FIELDPROC | | | | x | | | | |
| FILE | | | | x | x | x | | |
| FILLFACTOR | | | | | | x | | |
| FILTER | x | | | | | | | |
| FINAL | | | | x | | | | |
| FIRST | | | | | | | x | |
| FIRST1 | | | | x | | | | |
| FIRST_VALUE | x | | x | | | | | |
| FLOAT | x | x | x | | x | | x | x |
| FLOAT4 | | x | x | | | | | |
| FLOAT8 | | x | x | | | | | |
| FLOOR | x | | | | | | | |
| FOR | x | x | x | x | x | x | x | x |
| FORCE | | x | x | | | | | |
| FOREIGN | x | x | x | x | | x | x | x |
| FORTRAN | | | | | | | x | |
| FOUND | | | | | | | x | |
| FRAME_ROW | x | | | | | | | |
| FREE | x | | | x | | | | |
| FREETEXT | | | | | | x | | |
| FREETEXTTABLE | | | | | | x | | |
| FROM | x | x | x | x | x | x | x | x |
| FULL | x | | | x | | x | x | x |
| FULLTEXT | | x | x | | | | | |
| FUNCTION | x | | x | x | | x | | x |
| FUSION | x | | | | | | | |
| GENERAL | | x | | x | | | | |
| GENERATED | | | x | x | | | | |
| GET | x | | x | x | | | x | x |
| GLOBAL | x | | | x | | | x | |
| GO | | | | x | | | x | |
| GOTO | | | | x | | x | x | |
| GRANT | x | x | x | x | x | x | x | x |
| GRAPHIC | | | | x | | | | |
| GROUP | x | x | x | x | x | x | x | x |
| GROUPING | x | | x | | | | | |
| GROUPS | x | | x | | | | | |
| HANDLER | | | | x | | | | |
| HASH | | | | x | | | | |
| HASHED_VALUE | | | | x | | | | |
| HAVING | x | x | x | x | x | x | x | x |
| HIGH_PRIORITY | | x | x | | | | | |
| HINT | | | | x | | | | |
| HOLD | x | | | x | | | | |
| HOLDLOCK | | | | | | x | | |
| HOUR | x | | | x | | | x | |
| HOURS | | | | x | | | | |
| HOUR_MICROSECOND | | x | x | | | | | |
| HOUR_MINUTE | | x | x | | | | | |
| HOUR_SECOND | | x | x | | | | | |
| IDENTIFIED | | | | | x | | | |
| IDENTITY | x | | | x | | x | x | |
| IDENTITYCOL | | | | | | x | | |
| IDENTITY_INSERT | | | | | | x | | |
| IF | | x | x | x | | x | | x |
| IGNORE | | x | x | | | | | |
| IGNORE_DOMAIN_IDS | | x | | | | | | |
| IGNORE_SERVER_IDS | | x | | | | | | |
| IMMEDIATE | | | | x | x | | x | x |
| IMPORT | | | | x | | | | |
| IN | x | x | x | x | x | x | x | x |
| INCLUDE | | | | | | | x | |
| INCLUDING | | | | x | | | | |
| INCLUSIVE | | | | x | | | | |
| INCREMENT | | | | x | x | | | |
| INDEX | | x | x | x | x | x | x | x |
| INDICATOR | x | | | x | | | x | |
| INDICATORS | | | | x | | | | |
| INF | | | | x | | | | |
| INFILE | | x | x | | | | | |
| INFINITY | | | | x | | | | |
| INHERIT | | | | x | | | | |
| INITIAL | x | | | | x | | | |
| INITIALLY | | | | | | | x | |
| INNER | x | x | x | x | | x | x | x |
| INOUT | x | x | x | x | | | | x |
| INPUT | | | | | | | x | |
| INSENSITIVE | x | x | x | x | | | x | x |
| INSERT | x | x | x | x | x | x | x | x |
| INT | x | x | x | | | | x | x |
| INT1 | | x | x | | | | | |
| INT2 | | x | x | | | | | |
| INT3 | | x | x | | | | | |
| INT4 | | x | x | | | | | |
| INT8 | | x | x | | | | | |
| INTEGER | x | x | x | | x | | x | x |
| INTEGRITY | | | | x | | | | |
| INTERSECT | x | x | | x | x | x | x | x |
| INTERSECTION | x | | | | | | | |
| INTERVAL | x | x | x | | | | x | |
| INTO | x | x | x | x | x | x | x | x |
| IO_AFTER_GTIDS | | | x | | | | | |
| IO_BEFORE_GTIDS | | | x | | | | | |
| IS | x | x | x | x | x | x | x | x |
| ISNULL | | | | x | | | | |
| ISOBID | | | | x | | | | |
| ISOLATION | | | | x | | | x | |
| ITERATE | | x | x | x | | | | x |
| JAR | | | | x | | | | |
| JAVA | | | | x | | | | |
| JOIN | x | x | x | x | | x | x | x |
| JSON_ARRAY | x | | | | | | | |
| JSON_ARRAYAGG | x | | | | | | | |
| JSON_EXISTS | x | | | | | | | |
| JSON_OBJECT | x | | | | | | | |
| JSON_OBJECTAGG | x | | | | | | | |
| JSON_QUERY | x | | | | | | | |
| JSON_TABLE | x | | x | | | | | |
| JSON_TABLE_PRIMITIVE | x | | | | | | | |
| JSON_VALUE | x | | | | | | | |
| KEEP | | | | x | | | | |
| KEY | | x | x | x | | x | x | |
| KEYS | | x | x | | | | | |
| KILL | | x | x | | | x | | |
| LABEL | | | | x | | | | |
| LAG | x | | x | | | | | |
| LANGUAGE | x | | | x | | | x | |
| LARGE | x | | | | | | | |
| LAST | | | | | | | x | |
| LAST3 | | | | x | | | | |
| LAST_VALUE | x | | x | | | | | |
| LATERAL | x | | x | x | | | | |
| LC_CTYPE | | | | x | | | | |
| LEAD | x | | x | | | | | |
| LEADING | x | x | x | | | | x | x |
| LEAVE | | x | x | x | | | | x |
| LEFT | x | x | x | x | | x | x | x |
| LEVEL | | | | | x | | x | |
| LIKE | x | x | x | x | x | x | x | x |
| LIKE_REGEX | x | | | | | | | |
| LIMIT | | x | x | x | | | | x |
| LINEAR | | x | x | | | | | |
| LINENO | | | | | | x | | |
| LINES | | x | x | | | | | |
| LINKTYPE | | | | x | | | | |
| LISTAGG | x | | | | | | | |
| LN | x | | | | | | | |
| LOAD | | x | x | | | x | | |
| LOCAL | x | | | x | | | x | |
| LOCALDATE | | | | x | | | | |
| LOCALE | | | | x | | | | |
| LOCALTIME | x | x | x | x | | | | x |
| LOCALTIMESTAMP | x | x | x | x | | | | x |
| LOCATOR | | | | x | | | | |
| LOCATORS | | | | x | | | | |
| LOCK | | x | x | x | x | | | |
| LOCKMAX | | | | x | | | | |
| LOCKSIZE | | | | x | | | | |
| LOG | x | | | | | | | |
| LOG10 | x | | | | | | | |
| LONG | | x | x | x | x | | | |
| LONGBLOB | | x | x | | | | | |
| LONGTEXT | | x | x | | | | | |
| LOOP | | x | x | x | | | | x |
| LOWER | x | | | | | | x | |
| LOW_PRIORITY | | x | x | | | | | |
| MAINTAINED | | | | x | | | | |
| MASTER_BIND | | | x | | | | | |
| MASTER_HEARTBEAT_PERIOD | | x | | | | | | |
| MASTER_SSL_VERIFY_SERVER_CERT | | x | x | | | | | |
| MATCH | x | x | x | | | | x | x |
| MATCHES | x | | | | | | | |
| MATCH_NUMBER | x | | | | | | | |
| MATCH_RECOGNIZE | x | | | | | | | |
| MATERIALIZED | | | | x | | | | |
| MAX | x | | | | | | x | |
| MAXEXTENTS | | | | | x | | | |
| MAXVALUE | | x | x | x | | | | |
| MEDIUMBLOB | | x | x | | | | | |
| MEDIUMINT | | x | x | | | | | |
| MEDIUMTEXT | | x | x | | | | | |
| MEMBER | x | | | | | | | |
| MERGE | x | | | | | x | | |
| METHOD | x | | | | | | | |
| MICROSECOND | | | | x | | | | |
| MICROSECONDS | | | | x | | | | |
| MIDDLEINT | | x | x | | | | | |
| MIN | x | | | | | | x | |
| MINUS | | | | | x | | | |
| MINUTE | x | | | x | | | x | |
| MINUTES | | | | x | | | | |
| MINUTE_MICROSECOND | | x | x | | | | | |
| MINUTE_SECOND | | x | x | | | | | |
| MINVALUE | | | | x | | | | |
| MLSLABEL | | | | | x | | | |
| MOD | x | x | x | | | | | |
| MODE | | | | x | x | | | |
| MODIFIES | x | x | x | x | | | | |
| MODIFY | | | | | x | | | |
| MODULE | x | | | | | | x | |
| MONTH | x | | | x | | | x | |
| MONTHS | | | | x | | | | |
| MULTISET | x | | | | | | | |
| NAMES | | | | | | | x | |
| NAN | | | | x | | | | |
| NATIONAL | x | | | | | x | x | |
| NATURAL | x | x | x | | | | x | x |
| NCHAR | x | | | | | | x | |
| NCLOB | x | | | | | | | |
| NESTED_TABLE_ID | | | | | x | | | |
| NEW | x | | | x | | | | |
| NEW_TABLE | | | | x | | | | |
| NEXT | | | | | | | x | |
| NEXTVAL | | | | x | | | | |
| NO | x | | | x | | | x | |
| NOAUDIT | | | | | x | | | |
| NOCACHE | | | | x | | | | |
| NOCHECK | | | | | | x | | |
| NOCOMPRESS | | | | | x | | | |
| NOCYCLE | | | | x | | | | |
| NODENAME | | | | x | | | | |
| NODENUMBER | | | | x | | | | |
| NOMAXVALUE | | | | x | | | | |
| NOMINVALUE | | | | x | | | | |
| NONCLUSTERED | | | | | | x | | |
| NONE | x | | | x | | | x | |
| NOORDER | | | | x | | | | |
| NORMALIZE | x | | | | | | | |
| NORMALIZED | | | | x | | | | |
| NOT | x | x | x | | x | x | x | x |
| NOT2 | | | | x | | | | |
| NOTNULL | | | | x | | | | |
| NOWAIT | | | | | x | | | |
| NO_WRITE_TO_BINLOG | | x | x | | | | | |
| NTH_VALUE | x | | x | | | | | |
| NTILE | x | | x | | | | | |
| NULL | x | x | x | x | x | x | x | x |
| NULLIF | x | | | | | x | x | |
| NULLS | | | | x | | | | |
| NUM | | | | | | | | x |
| NUMBER | | | | | x | | | x |
| NUMERIC | x | x | x | | | | x | x |
| NUMPARTS | | | | x | | | | |
| OBID | | | | x | | | | |
| OCCURRENCES_REGEX | x | | | | | | | |
| OCTET_LENGTH | x | | | | | | x | |
| OF | x | | x | x | x | x | x | x |
| OFF | | | | x | | x | | |
| OFFLINE | | | | | x | | | |
| OFFSET | x | | | x | | | | |
| OFFSETS | | | | | | x | | |
| OLD | x | | | x | | | | |
| OLD_TABLE | | | | x | | | | |
| OMIT | x | | | | | | | |
| ON | x | x | x | x | x | x | x | x |
| ONE | x | | | | | | | |
| ONLINE | | | | | x | | | |
| ONLY | x | | | | | | x | |
| OPEN | x | | | x | | x | x | |
| OPENDATASOURCE | | | | | | x | | |
| OPENQUERY | | | | | | x | | |
| OPENROWSET | | | | | | x | | |
| OPENXML | | | | | | x | | |
| OPTIMIZATION | | | | x | | | | |
| OPTIMIZE | | x | x | x | | | | |
| OPTIMIZER_COSTS | | | x | | | | | |
| OPTION | | x | x | x | x | x | x | |
| OPTIONALLY | | x | x | | | | | |
| OR | x | x | x | x | x | x | x | x |
| ORDER | x | x | x | x | x | x | x | x |
| OUT | x | x | x | x | | | | x |
| OUTER | x | x | x | x | | x | x | x |
| OUTFILE | | x | x | | | | | |
| OUTPUT | | | | | | | x | |
| OVER | x | x | x | x | | x | | x |
| OVERLAPS | x | | | | | | x | |
| OVERLAY | x | | | | | | | |
| OVERRIDING | | | | x | | | | |
| PACKAGE | | | | x | | | | |
| PAD | | | | | | | x | |
| PADDED | | | | x | | | | |
| PAGESIZE | | | | x | | | | |
| PAGE_CHECKSUM | | x | | | | | | |
| PARAMETER | x | | | x | | | | |
| PARSE_VCOL_EXPR | | x | | | | | | |
| PART | | | | x | | | | |
| PARTIAL | | | | | | | x | x |
| PARTITION | x | x | x | x | | | | x |
| PARTITIONED | | | | x | | | | |
| PARTITIONING | | | | x | | | | |
| PARTITIONS | | | | x | | | | |
| PASCAL | | | | | | | x | |
| PASSWORD | | | | x | | | | |
| PATH | | | | x | | | | |
| PATTERN | x | | | | | | | |
| PCTFREE | | | | | x | | | |
| PER | x | | | | | | | |
| PERCENT | x | | | x | | x | | |
| PERCENTILE_CONT | x | | | | | | | |
| PERCENTILE_DISC | x | | | | | | | |
| PERCENT_RANK | x | | x | | | | | |
| PERIOD | x | | | | | | | |
| PIECESIZE | | | | x | | | | |
| PIVOT | | | | | | x | | |
| PLAN | | | | x | | x | | |
| PORTION | x | | | | | | | |
| POSITION | x | x | | x | | | x | |
| POSITION_REGEX | x | | | | | | | |
| POWER | x | | | | | | | |
| PRAGMA | | | | | | | | x |
| PRECEDES | x | | | | | | | |
| PRECISION | x | x | x | x | | x | x | x |
| PREPARE | x | | | x | | | x | |
| PRESERVE | | | | | | | x | |
| PREVVAL | | | | x | | | | |
| PRIMARY | x | x | x | x | | x | x | x |
| PRINT | | | | | | x | | |
| PRIOR | | | | | x | | x | |
| PRIQTY | | | | x | | | | |
| PRIVILEGES | | | | x | | | x | |
| PROC | | | | | | x | | |
| PROCEDURE | x | x | x | x | | x | x | x |
| PROGRAM | | | | x | | | | |
| PSID | | | | x | | | | |
| PTF | x | | | | | | | |
| PUBLIC | | | | x | x | x | x | |
| PURGE | | x | x | | | | | |
| QUERY | | | | x | | | | |
| QUERYNO | | | | x | | | | |
| RAISERROR | | | | | | x | | |
| RANGE | x | x | x | x | | | | x |
| RANK | x | | x | x | | | | x |
| RAW | | | | | x | | | |
| READ | | x | x | x | | x | x | |
| READS | x | x | x | x | | | | x |
| READTEXT | | | | | | x | | |
| READ_WRITE | | x | x | | | | | |
| REAL | x | x | x | | | | x | x |
| RECONFIGURE | | | | | | x | | |
| RECOVERY | | | | x | | | | |
| RECURSIVE | x | x | x | | | | | x |
| REF | x | | | | | | | |
| REFERENCES | x | x | x | x | | x | x | x |
| REFERENCING | x | | | x | | | | |
| REFRESH | | | | x | | | | |
| REF_SYSTEM_ID | | x | | | | | | |
| REGEXP | | x | x | | | | | x |
| REGR_AVGX | x | | | | | | | |
| REGR_AVGY | x | | | | | | | |
| REGR_COUNT | x | | | | | | | |
| REGR_INTERCEPT | x | | | | | | | |
| REGR_R2 | x | | | | | | | |
| REGR_SLOPE | x | | | | | | | |
| REGR_SXX | x | | | | | | | |
| REGR_SXY | x | | | | | | | |
| REGR_SYY | x | | | | | | | |
| RELATIVE | | | | | | | x | |
| RELEASE | x | x | x | x | | | | x |
| RENAME | | x | x | x | x | | | x |
| REPEAT | | x | x | x | | | | x |
| REPLACE | | x | x | | | | | x |
| REPLICATION | | | | | | x | | |
| REQUIRE | | x | x | | | | | |
| RESET | | | | x | | | | |
| RESIGNAL | | x | x | x | | | | x |
| RESOURCE | | | | | x | | | |
| RESTART | | | | x | | | | |
| RESTORE | | | | | | x | | |
| RESTRICT | | x | x | x | | x | x | |
| RESULT | x | | | x | | | | |
| RESULT_SET_LOCATOR | | | | x | | | | |
| RETURN | x | x | x | x | | x | | x |
| RETURNING | | x | | | | | | |
| RETURNS | x | | | x | | | | |
| REVERT | | | | | | x | | |
| REVOKE | x | x | x | x | x | x | x | x |
| RIGHT | x | x | x | x | | x | x | x |
| RLIKE | | x | x | | | | | |
| ROLE | | | | x | | | | |
| ROLLBACK | x | | | x | | x | x | x |
| ROLLUP | x | | | | | | | |
| ROUND_CEILING | | | | x | | | | |
| ROUND_DOWN | | | | x | | | | |
| ROUND_FLOOR | | | | x | | | | |
| ROUND_HALF_DOWN | | | | x | | | | |
| ROUND_HALF_EVEN | | | | x | | | | |
| ROUND_HALF_UP | | | | x | | | | |
| ROUND_UP | | | | x | | | | |
| ROUTINE | | | | x | | | | |
| ROW | x | | x | x | x | | | x |
| ROWCOUNT | | | | | | x | | |
| ROWGUIDCOL | | | | | | x | | |
| ROWID | | | | | x | | | |
| ROWNUM | | | | | x | | | |
| ROWNUMBER | | | | x | | | | |
| ROWS | x | x | x | x | x | | x | x |
| ROWSET | | | | x | | | | |
| ROW_NUMBER | x | | x | x | | | | x |
| RRN | | | | x | | | | |
| RULE | | | | | | x | | |
| RUN | | | | x | | | | |
| RUNNING | x | | | | | | | |
| SAVE | | | | | | x | | |
| SAVEPOINT | x | | | x | | | | x |
| SCALAR | | | | | | | | x |
| SCHEMA | | x | x | x | | x | x | |
| SCHEMAS | | x | x | | | | | |
| SCOPE | x | | | | | | | |
| SCRATCHPAD | | | | x | | | | |
| SCROLL | x | | | x | | | x | |
| SEARCH | x | | | x | | | | |
| SECOND | x | | | x | | | x | |
| SECONDS | | | | x | | | | |
| SECOND_MICROSECOND | | x | x | | | | | |
| SECQTY | | | | x | | | | |
| SECTION | | | | | | | x | |
| SECURITY | | | | x | | | | |
| SECURITYAUDIT | | | | | | x | | |
| SEEK | x | | | | | | | |
| SELECT | x | x | x | x | x | x | x | x |
| SEMANTICKEYPHRASETABLE | | | | | | x | | |
| SEMANTICSIMILARITYDETAILSTABLE | | | | | | x | | |
| SEMANTICSIMILARITYTABLE | | | | | | x | | |
| SENSITIVE | x | x | x | x | | | | x |
| SEPARATOR | | x | x | | | | | |
| SEQUENCE | | | | x | | | | |
| SESSION | | | | x | x | | x | x |
| SESSION_USER | x | | | x | | x | x | |
| SET | x | x | x | x | x | x | x | x |
| SETUSER | | | | | | x | | |
| SHARE | | | | | x | | | |
| SHOW | x | x | x | | | | | |
| SHUTDOWN | | | | | | x | | |
| SIGNAL | | x | x | x | | | | x |
| SIMILAR | x | | | | | | | |
| SIMPLE | | | | x | | | | x |
| SIN | x | | | | | | | |
| SINH | x | | | | | | | |
| SIZE | | | | | x | | x | |
| SKIP | x | | | | | | | |
| SLOW | | x | | | | | | |
| SMALLINT | x | x | x | | x | | x | x |
| SNAN | | | | x | | | | |
| SOME | x | | | x | | x | x | |
| SOURCE | | | | x | | | | |
| SPACE | | | | | | | x | |
| SPATIAL | | x | x | | | | | |
| SPECIFIC | x | x | x | x | | | | x |
| SPECIFICTYPE | x | | | | | | | |
| SQL | x | x | x | x | | | x | x |
| SQLCA | | | | | | | x | |
| SQLCODE | | | | | | | x | |
| SQLERROR | | | | | | | x | |
| SQLEXCEPTION | x | x | x | | | | | |
| SQLID | | | | x | | | | |
| SQLSTATE | x | x | x | | | | x | |
| SQLWARNING | x | x | x | | | | x | |
| SQL_BIG_RESULT | | x | x | | | | | |
| SQL_CALC_FOUND_ROWS | | x | x | | | | | |
| SQL_SMALL_RESULT | | x | x | | | | | |
| SQRT | x | | | | | | | |
| SSL | | x | x | | | | | |
| STACKED | | | | x | | | | |
| STANDARD | | | | x | | | | |
| START | x | | | x | x | | | x |
| STARTING | | x | x | x | | | | |
| STATEMENT | | | | x | | | | |
| STATIC | x | | | x | | | | |
| STATISTICS | | | | | | x | | |
| STATMENT | | | | x | | | | |
| STATS_AUTO_RECALC | | x | | | | | | |
| STATS_PERSISTENT | | x | | | | | | |
| STATS_SAMPLE_PAGES | | x | | | | | | |
| STAY | | | | x | | | | |
| STDDEV_POP | x | | | | | | | |
| STDDEV_SAMP | x | | | | | | | |
| STOGROUP | | | | x | | | | |
| STORED | | | x | | | | | |
| STORES | | | | x | | | | |
| STRAIGHT_JOIN | | x | x | | | | | |
| STRING | | | | | | | | x |
| STYLE | | | | x | | | | |
| SUBMULTISET | x | | | | | | | |
| SUBSET | x | | | | | | | |
| SUBSTRING | x | | | x | | | x | |
| SUBSTRING_REGEX | x | | | | | | | |
| SUCCEEDS | x | | | | | | | |
| SUCCESSFUL | | | | | x | | | |
| SUM | x | | | | | | x | |
| SUMMARY | | | | x | | | | |
| SYMMETRIC | x | | | | | | | |
| SYNONYM | | | | x | x | | | |
| SYSDATE | | | | | x | | | |
| SYSFUN | | | | x | | | | |
| SYSIBM | | | | x | | | | |
| SYSPROC | | | | x | | | | |
| SYSTEM | x | | x | x | | | | x |
| SYSTEM_TIME | x | | | | | | | |
| SYSTEM_USER | x | | | x | | x | x | |
| TABLE | x | x | x | x | x | x | x | x |
| TABLESAMPLE | x | | | | | x | | |
| TABLESPACE | | | | x | | | | |
| TAN | x | | | | | | | |
| TANH | x | | | | | | | |
| TEMPORARY | | | | | | | x | |
| TERMINATED | | x | x | | | | | |
| TEXT | | | | | | | | x |
| TEXTSIZE | | | | | | x | | |
| THEN | x | x | x | x | x | x | x | x |
| TIME | x | | | x | | | x | |
| TIMESTAMP | x | | | x | | | x | |
| TIMEZONE_HOUR | x | | | | | | x | |
| TIMEZONE_MINUTE | x | | | | | | x | |
| TINYBLOB | | x | x | | | | | |
| TINYINT | | x | x | | | | | |
| TINYTEXT | | x | x | | | | | |
| TO | x | x | x | x | x | x | x | x |
| TOP | | | | | | x | | |
| TRAILING | x | x | x | | | | x | x |
| TRAN | | | | | | x | | |
| TRANSACTION | | | | x | | x | x | x |
| TRANSLATE | x | | | | | | x | |
| TRANSLATE_REGEX | x | | | | | | | |
| TRANSLATION | x | | | | | | x | |
| TREAT | x | | | | | | | |
| TRIGGER | x | x | x | x | x | x | | x |
| TRIM | x | | | x | | | x | x |
| TRIM_ARRAY | x | | | | | | | |
| TRUE | x | x | x | | | | x | x |
| TRUNCATE | x | | | x | | x | | x |
| TRY_CONVERT | | | | | | x | | |
| TSEQUAL | | | | | | x | | |
| TYPE | | | | x | | | | |
| UESCAPE | x | | | | | | | |
| UID | | | | | x | | | |
| UNDO | | x | x | x | | | | |
| UNION | x | x | x | x | x | x | x | x |
| UNIQUE | x | x | x | x | x | x | x | x |
| UNKNOWN | x | | | | | | x | x |
| UNLOCK | | x | x | | | | | |
| UNNEST | x | | | | | | | |
| UNPIVOT | | | | | | x | | |
| UNSIGNED | | x | x | | | | | x |
| UNTIL | | | | x | | | | |
| UPDATE | x | x | x | x | x | x | x | x |
| UPDATETEXT | | | | | | x | | |
| UPPER | x | | | | | | x | |
| USAGE | | x | x | x | | | x | |
| USE | | x | x | | | x | | |
| USER | x | | | x | x | x | x | x |
| USING | x | x | x | x | | | x | x |
| UTC_DATE | | x | x | | | | | |
| UTC_TIME | | x | x | | | | | |
| UTC_TIMESTAMP | | x | x | | | | | |
| VALIDATE | | | | | x | | | |
| VALIDPROC | | | | x | | | | |
| VALUE | x | | | x | | | x | |
| VALUES | x | x | x | x | x | x | x | x |
| VALUE_OF | x | | | | | | | |
| VARBINARY | x | x | x | | | | | x |
| VARCHAR | x | x | x | | x | | x | x |
| VARCHAR2 | | | | | x | | | |
| VARCHARACTER | | x | x | | | | | |
| VARIABLE | | | | x | | | | |
| VARIANT | | | | x | | | | |
| VARYING | x | x | x | | | x | x | |
| VAR_POP | x | | | | | | | |
| VAR_SAMP | x | | | | | | | |
| VCAT | | | | x | | | | |
| VERSION | | | | x | | | | |
| VERSIONING | x | | | | | | | |
| VIEW | | | | x | x | x | x | x |
| VIRTUAL | | | x | | | | | |
| VOLATILE | | | | x | | | | |
| VOLUMES | | | | x | | | | |
| WAITFOR | | | | | | x | | |
| WHEN | x | x | x | x | | x | x | x |
| WHENEVER | x | | | x | x | | x | x |
| WHERE | x | x | x | x | x | x | x | x |
| WHILE | | x | x | x | | x | | x |
| WIDTH_BUCKET | x | | | | | | | |
| WINDOW | x | x | x | | | | | |
| WITH | x | x | x | x | x | x | x | x |
| WITHIN | x | | | | | x | | |
| WITHOUT | x | | | x | | | | |
| WLM | | | | x | | | | |
| WORK | | | | | | | x | |
| WRITE | | x | x | x | | | x | |
| WRITETEXT | | | | | | x | | |
| XMLELEMENT | | | | x | | | | |
| XMLEXISTS | | | | x | | | | |
| XMLNAMESPACES | | | | x | | | | |
| XOR | | x | x | | | | | |
| YEAR | x | | | x | | | x | |
| YEARS | | | | x | | | | |
| YEAR_MONTH | | x | x | | | | | |
| ZEROFILL | | x | x | | | | | |
| ZONE | | | | | | | x | |
+----------------------------------+-----+-----+-----+-----+-----+-----+-----+-----+
The concept of autocompletion is old and simple. You type some characters; the program shows some choices for what characters might follow; you can choose a choice by hitting a special key. It can save on typing, and save on looking up in dictionaries or information schemas.
I will illustrate what the manuals mean, then show features or quirks that the manuals fail to say, then compare with a GUI.
The Example
For The Example, I used MySQL 8.0 mysql client and MariaDB 10.5 mysql client, on Linux. I understand that they work on Windows 10 if you install a Linux shell.
You should find it easy to follow along with your own copy of mysql client, even if you started with non-default options and have minimal privileges.
The first thing to do is declare a “current database” with USE, and say that you want to enable autocompletion with REHASH.
I’ll discuss later why these might be unnecessary statements, but there’s no harm in making sure.
USE information_schema;
REHASH;
Now type lo then type the [Tab] key twice. Your screen will look like this:
Now type the [Backspace] key twice, then type LO, then type the [Tab] key twice. Your screen will look like this (the items might be in a different order depending on the server):
Now type the [Backspace] key twice, then type LOCALTIMEST, then type the [Tab] key once. Your screen will look like this:
At this point you have probably figured out these things:
* Searching is case sensitive, lo and LO are different
* If there is more than one choice, [Tab] [Tab] causes a display
* If there is only one choice, [Tab] causes a replacement
* Context is irrelevant, most of the choices would be illegal as statement start
* Choices include table names, column names, and keywords.
To complete what you could figure out, you could try these additional tests: inf [Tab] [Tab] — you’ll see information_schema because choices also include database names BEG [Tab] [Tab] — you’ll see BEGIN because choices also include non-reserved keywords INF [Tab] [Tab] — there will be a question whether you want to see all choices because 100+ choices may not be a useful hint.
Command line options
To back up a bit, the reason that the USE and REHASH statements might have been unnecessary is that there might be defaults.
If you started mysql with --database=database_name or -D database_name, then USE is automatic when you connect.
If you started mysql with –auto_rehash, or you just omitted the option because it is default default, then REHASH is automatic when you USE.
Do not let the “auto” in “–auto-rehash” deceive you too much though. REHASH will not happen automatically if anyone changes the current database with CREATE or DROP or ALTER. REHASH will not happen automatically if you say USE x; when x is already the default database.
So if you worry about depending on obsolete choices, you will need to do manual REHASHes occasionally.
The REHASH Statement
prompt> REHASH; /* or /# */
REHASH is not a good name — it hints about how the job is implemented, rather than what it does, which is: select the names of databases, names of tables (both base tables and viewed tables but not temporary tables) in the current database, names of columns of those tables, keywords (both reserved words and unreserved words), and names of mysql commands. Completion will not work if REHASH has not happened, not even for keywords.
REHASH will not select names of tables that you don’t have privileges for. There is a small security breach though: If you have a column-level privilege for any column in the table, then the menu choices will include all columns in the table, including the ones you don’t have privileges for. (In theory you are not supposed to know about such columns, which is why you won’t see them in information_schema.)
Unlike USE, which tells you “Reading table information for completion of table and column names”, REHASH gives no feedback. But it does succeed. If you have only a few thousand tables and columns, it takes negligible time.
What library mysql is using
For most editing operations, including [Tab] handling, the mysql client passes off the work to an open-source library, either readline or libedit.
If you have an old MySQL version, or if you have MariaDB, your mysql client probably has readline. One way to tell is to say
mysql --help | grep readline
Any non-blank response, for example
mysql Ver 15.1 Distrib 10.1.47-MariaDB,
for debian-linux-gnu (x86_64)
using readline 5.2
indicates that your mysql client has readline. Alternatively you could say “whereis mysql … ldd mysql-location” and look for libreadline.so in the output.
If you have MySQL 5.6.5 or later, your mysql client almost certainly has bundled libedit. (In version 5.5 there was still a CMake option -DWITH_READLINE=1, but it is gone now.) If you have MariaDB, your mysql client probably does not have libedit unless you built from source and passed the -DWITH_LIBEDIT option to cmake. One way to tell is to create a file named ~/.editrc and insert this temporary line:
mysql:bind
(If the file already exists, no problem, just add a line saying mysql:bind at the start.) Now start the mysql client. If it displays a list titled “Standard key bindings”, then your client has libedit. Specifically it is close to the NetBSD variation of libedit. Now remove the line saying mysql:bind from libedit.
It has been suggested that MySQL/Oracle’s changed preference was due more to licence considerations than to features (readline is GPL and libedit is BSD), and indeed it is true that there are more things you can do with autocompletion if you use the mysql client from MariaDB, as we will see.
Today (November 6 2020) the MySQL 8.0 manual still has mentions of readline, here and here and here. They are obsolete, ignore them.
Using a different key instead of [Tab]
The special key for completion is [Tab] so sometimes autocompletion is called “tab completion”. But it doesn’t have to be. You can change the “key binding” — the way that a particular key is connected to a particular operation — by changing a file that the library reads when you start the mysql client. There is no denying that [Tab] is the more popular choice on Linux, partly because it is the default for both libedit and readline, and some Linux utilities such as bash depend on readline. But [Tab] is a displayable character so it is unusual — and I think bizarre — to see it within an application that is editing text. There is a way to say “Let [Tab] be [Tab], and use a control character for completion.”
If the library is libreadline, then the file to change is ~/.inputrc. If it does not already exist, then you can create it, but then be sure to $include /etc/inputrc at the top, otherwise the user’s copy will just override the system one. Make it look like this:
Unless you have an exotic terminal, [Tab] and Control-I have the same effect.
If the library is libedit, then the file to change is ~/.editrc and the key binding that matters for completion is rl_complete. Edit ~/.editrc again and remove the line that says bind, and add these lines:
I like it that I can specify that I only want to affect mysql.
Now start the mysql client again, and once again say
USE information_schema;
REHASH;
DROP TABLE
and now type control-N twice. You will see that it displays exactly the same thing that you saw when you typed [Tab] twice. However, if you now type [Tab], you will get a tab.
Warning: before changing a key binding, make sure that the key is not used by other programs or has some default libreadline/libedit binding already. And check with stty -a.
Undocumented readline features
Actually these key bindings are documented for readline,
but the MySQL and MariaDB manuals don’t list them so I’m
guessing most mysql users don’t know about them. To see what the relevant key bindings are, I use bind:
$ bind -P | grep complete
complete can be found on "\C-n", "\e\e".
complete-command can be found on "\e!".
complete-filename can be found on "\e/".
complete-hostname can be found on "\e@".
complete-into-braces can be found on "\e{".
complete-username can be found on "\e~".
complete-variable can be found on "\e$".
dynamic-complete-history can be found on "\e\C-i".
glob-complete-word can be found on "\eg".
menu-complete is not bound to any keys
menu-complete-backward is not bound to any keys
old-menu-complete is not bound to any keys
vi-complete is not bound to any keys
This is rather cryptic but you probably can guess that “\C-n” means “Control-N”, which is the suggestion that I made for ~/.inputrc. However, the interesting items are menu-complete and menu-complete-backward. Let’s bind them to some keys and see what a readline-based mysql client does with them.
First change ~/.inputrc again so now it looks like this:
Now start mysql again and do some of the same steps as before:
USE information_schema;
REHASH;
And now type LO and then type control-N twice
(not [Tab] any more), and you’ll see
Now type Control-J. Suddenly the word becomes the first choice
in the menu
Now type Control-J again. Now the word becomes the second choice in the menu
Keep typing Control-J and eventually readline will cycle back
to the first choice. Or type control-K and completions will be of the previous items.
This, I think, is how autocompletion should always work.
If you have a menu of choices, you should have a way to
navigate to a specific choice by typing a single key.
Try out even more behaviour changes by adding these lines at the end of ~/.inputrc:
# Case-insensitive (disabled)
set completion-ignore-case On
# Don't do anything until user types at least 3 characters (disabled)
set completion-prefix-display-length 3
# If there are more than 5 choices ask "Display all xx possibilities?"
set completion-query-items 5
# Of course disable-completion No is default
set disable-completion No
# If there are many choices don't show a page at a time and ask for "More"
set page-completions Off
# Menu options should be vertical, that would be normal (disabled)
set print-completions-horizontally No
# If there are two or more choices show them after hitting special key once
set show-all-if-ambiguous Yes
# Show what is changed (disabled)
set show-all-if-unmodified On
# If it is completed then put the cursor after it
set skip-completed-text On
# Don't hear a bell, see a bell (disabled)
set bell-style visible
These are not libedit features, but I shouldn’t omit mentioning that libedit has many other key bindings and customization chances, unrelated to autocompletion. It is not hard to use MariaDB’s mysql client to connect to MySQL’s server, but I doubt it’s worthwhile just for some extra autocomplete gizmos.
In a GUI client
It should be clear that the mysql client does an adequate autocompletion job. But I can think of many clients that do a better job, from either MySQL or third parties. I am only going to illustrate one of them — our ocelotgui — but I am not suggesting that it is unique in this respect, since any competent GUI will have at least a few of these additional features. And I am not suggesting that any one of these additional features is important — only “autocompletion” itself is important. But I think that as a whole they save some time and trouble.
You should be able to follow along with your own copy of ocelotgui, if you have downloaded the latest version from github.
Say USE information_schema and REHASH.
Change so completion is done with Alt-N rather than [Tab].
Type DROP TABLE
Move the cursor and hover, to see instructions.
Use the down-arrow to select one of the menu items.
Type Alt-N or click Autocomplete on the main Edit menu
Wait OCELOT_COMPLETER_TIMEOUT seconds for the menu to disappear.
Notice these differences …
(1) Changing [Tab] can be done within the program (although of course it can also be done by changing a file).
(2) The choices appear immediately, with a GUI there’s no need for [Tab] or a special key to make them appear.
(3) The choices include only what is relevant in context, i.e. after DROP TABLE the only possible items are IF and table names.
(4) The colour of the choices is the same as the colour of the highlighting, which is why IF (a keyword) and * (an identifier) look different.
(5) The navigation is done with arrow keys on a purely vertical menu with a scroll bar, regardless of number of choices.
(6) Hints and menu choices appear temporarily, as in IDEs.
Another difference is that this works the same way on Windows as well as Linux, out of the box.
Of course you can’t actually drop a table in information_schema, and ocelotgui will fail to warn you about that. I admit as much. “Perfection” is still on the to-do list.
What should be the result of -11 % 4, or MOD(11, -4)?
This has been controversial and you will get different results in different languages. However, in SQL there is only one correct answer, the one that the SQL standard requires. Good news: your favourite SQL DBMS gives the correct answer. But what it is, and what the proof is, will need lots of explaining.
Modulus moduli modulo
Oxford English Dictionary entry for modulus: “… 2b A whole number used as a divisor in a system of arithmetic (modular arithmetic) in which integers having the same remainder when divided by this number are regarded as equivalent. Cf. congruent adj. 5, modulo prep., residue n. 3b.”
Oxford English Dictionary entry for modulo: “Origin: A borrowing from Latin. Etymons: Latin modulō, modulus. Etymology: < classical Latin modulō, ablative of modulus modulus n. Compare earlier mod prep. The preposition was first used in this sense in a Latin context by Gauss in 1801 (see note s.v. mod prep.). … a. With respect to a modulus of (a specified value). See modulus n. 2b.”
Carl Friedrich Gauss wrote Disquisitiones Arithmeticae in Latin. In Latin, moduli is the plural of modulus and modulo is the ablative. In this context the ablative modulo indicates “by means of the modulus”.
And so R = N MOD M means get a result R by applying to a number N “by means of the modulus M“. In SQL this is the standard function MOD(N, M)
or the common operator N % M.
I highlight the fact that the modulus here is M — sometimes I’ve seen hints that people think the modulus is the result of the function, but that’s not the original meaning. There are good explanations of “modular arithmetic” on the Khan Academy site and in Encyclopedia Britannica which use the term in the original way, and use the common illustration of a circular clock that has 12 hours marked on it:
If it is 7 o’clock, and you add 7 hours, then it is 2 o’clock. It doesn’t mean 7+7=2, it means 7+7 and 2 are “congruent” by means of modulus 12. So are (7+7+12) and 2, (7+7+12*2) and 2, and so on. The mod function should answer: what’s the congruent number that fits on the clock?
Anybody can see that, but real-world examples of a “negative clock” are harder to find. I can think of a clock that counts down before a rocket launch, but it doesn’t go in a cycle.Nevertheless, if it did, then the hours are not from 0 to 11, they are from 0 to -11. Now, if you add 7 hours to “minus 7 o’clock” or if you subtract 7 hours from “minus 7 o’clock”, arguably you should get a negative number, as no positive number fits on a negative clock.
On the other hand, people want to use this function to get remainders and remainders are normally positive numbers regardless what you use as a divisor. So what’s desirable?
The three main possibilities
Daan Leijen wrote “Division and Modulus for Computer Scientists” following some work by Knuth and Wirth and others. It is not in Latin. But it does have some mathematical symbols, which I’ll translate …
Assume divisor <> 0.
(1) the quotient is a member of the set of integers.
(2) Dividend = divisor times quotient + remainder.
(3) ABS(remainder) < ABS(divisor).
Those are the universal rules. The additional rules can be:
(a) “Truncate”, i.e. trunc(dividend / divisor) – (dividend * result)
(b) “Floor”, i.e. it’s the remainder of round(quotient) towards infinity)
(c) “Euclidean”, i.e. what Mr Leijen regards as correct, see his lengthy explanation, but he admits it’s rarely used.
The key illustration is Mr Leijen’s “Comparison of T-, F- and E-division”
where T is Truncate, F is Floor, E is Euclidean, D is Dividend, d is divisor, q is quotient, r is remainder,
The exciting part is that when the Dividend is negative (-8,+3 or -8,-3), or when the divisor is negative (+8,-3 or -8,-3) the column with “rT”, i.e. remainder with Truncate, is not the same as the column with “rF”, i.e. remainder with Floor.
Modern C goes with (a) Truncate, which tends to be well supported by the processor. If you write and run this program:
Same in MariaDB. Same in Tarantool. Same in PostgreSQL. Same in Oracle … but Oracle warns: this is not the “classical” modulus operation. Then Oracle illustrates what they call “classical” and, it’s obvious from that illustration, they mean Floor. IBM uses the same example.
Therefore the overwhelming opinion among SQL vendors is (a) Truncate.
What the standard says
There is no % operator. There is a MOD() function.
"
<modulus expression> ::=
MOD <left paren>
<numeric value expression dividend>
<comma>
<numeric value expression divisor>
<right paren>
...
If <modulus expression> is specified,
then the declared type of each
<numeric value expression>
shall be exact numeric with scale 0 (zero).
The declared type of the result is the
declared type of the immediately contained
<numeric value expression divisor>.
...
9)If <modulus expression> is specified,
then let N be the value of the immediately
contained <numeric value expression
dividend> and let M be the value of the
immediately contained <numeric value
expression divisor>.
Case:
a)If at least one of N and M is the null
value, then the result is the null value.
b)If M is zero,
then an exception condition is raised:
data exception—division by zero.
c)Otherwise, the result is the unique exact
numeric value R with scale 0 (zero) such
that all of the following are true:
i)R has the same sign as N.
ii)The absolute value of R is less than
the absolute value of M.
iii)N = M * K + R for some exact numeric
value K with scale 0 (zero).
“
Look again at Mr Leijen’s universal rules, above. You’ll notice that the numeric-with-scale-0 requirement is equivalent to “(1) the quotient is a member of the set of integers.”, and you’ll notice that clause b) is equivalent to “Assume divisor <> 0”, and you’ll notice that clause c)iii) is equivalent to “(2) Dividend = divisor times quotient + remainder”, and you’ll notice that clause c)ii) is equivalent to “(3) ABS(remainder) < ABS(divisor).” So, except for clause c)i), all the rules are the rules that he described.
So what is -11 % 4?
It is the same as MOD(-11, 4).
Therefore -11 is the dividend and 4 is the divisor.
Therefore -11 is N and 4 is M.
a) does not apply because neither M nor N is NULL.
b) does not apply because M is not zero.
c) means for the expression N = M * K + R, we must solve for K and R.
Plugging in the values of N and M, we have -11 = 4 * K + R.
Since R must have the same sign as N, R must be negative.
Therefore K must be negative!
To see why, plug in any value of K which is >= 0. For example: -11 = 4 * 1 + -15
No. This violates c)ii) because ABS(-15) > ABS(4).
So now we know that -11 = 4 * (K which is a negative number) + (R which is a negative number).
Let us try with K >= -1: -11 = 4 * (-1) + (-7)
No. This violates c)ii) because ABS(-7) > ABS(4).
Okay, how about if K <= -3: -11 = 4 * (-3) + (+1)
No. This violates c)i) because N is negative and R is positive.
Okay, how about K = -2: -11 = 4 * (-2) + (-3)
This does not violate c)i) because N is negative and R is negative.
This does not violate c)ii) because ABS(-3) < ABS(4).
Great, so R = -3.
Thus it is established by example that the standard requires (a) Truncate.
Using non-standard extensions
Although in standard SQL the correct action for MOD(N, 0) is an error “division by zero”, not every vendor does that — they might return N or they might return NULL.
Although standard SQL MOD() is for integers, some vendors allow FLOAT or DECIMAL. And here is a trick: To get the scalar part of a DECIMAL number: 5.5 % 1
result should be .5.
Perhaps you are thinking “Nonsense! The correct way is 5.5 - FLOOR(5.5)
but I think it depends whether you want to preserve the sign.
Although the standard says that the result data type should be the same data type as M, some vendors will return a value with different precision and scale.
New ocelotgui version
Version 1.1.0 of ocelotgui was released on July 31. So head over to our github site now and download.
I have written code that converts SQL stored procedures to Lua functions. This might interest people who want to know what’s involved for any C-like target language. Here I will display one step at a time, emphasizing the “Design Decisions” that I had to make, giving increasingly complex examples. Then I’ll note the limitations and say how to get the source code. Alpha.
Frame
CREATE LUA PROCEDURE p()
BEGIN
/* Empty block */
END;
The word LUA is just a signal that this is a translation job; everything following it is expected to be standard SQL or a supported dialect.
I already had a good recognizer so parsing the input is easy. And, so far, it’s easy to find Lua syntax analogous to SQL syntax. The result is:
function P()
do
--[[/* Empty block */]]
end;
end;
Design Decision #1: I’ll try to preserve comments and punctuation as in the original, although it’s not necessary.
Design Decision #2: SQL’s BEGIN … END can become Lua’s do … end
The alternative was Lua’s while true … break; end but that could have confused some people.
Variables
CREATE LUA PROCEDURE p()
BEGIN
DECLARE i INTEGER;
DECLARE "Peter's string" VARCHAR(4);
END;
DECLARE + variable-name is easy because Lua declarations only need a name. Occasionally we have to do some extra processing though.
Result:
do
local I;
local Peter_39_s_32_string_33_;
end;
end;
Design Decision #3: I convert regular identifiers to upper case because that’s how SQL does things. This isn’t common practice in Lua.
Design Decision #4: I change delimited (quoted) identifiers by changing all special characters to _s but keeping the original case, and then we add a number to ensure the name is unique. Detail: _33 means “the definition was at token number 33 in the CREATE PROCEDURE statement; I use token numbers frequently to make sure I’m making something unique.
Design Decision #5: I don’t preserve the data type. Lua doesn’t need it often and when it does I can use Lua’s type() function to see whether somethingis a number or a string … except if the value is nil. Nil values will confuse us and users should try to avoid them. The alternative, though, was to store the data type and null status separately for every declared variable, and I think (well, “hope”) that won’t be necessary in practice.
Executing
CREATE LUA FUNCTION f() RETURNS INTEGER
BEGIN
DECLARE i INTEGER DEFAULT 1;
RETURN i + 3;
END;
Now we get into SQL statements that must be called from Lua. For this we will use a function named sql_execute(), which is a wrapper around code that is specific to a particular DBMS. The job of sql_execute is to:
Pass parameters.
Send a statement to the DBMS server (for example with mysql_real_query if the DBMS is MySQL/MariaDB).
NB: sending should be done with Lua pcall because results must always be intercepted.
Check return values:
(If there was an error) set sqlstate to error, for example ‘45000’, and return false.
(If there was a result set)
Copy the result set to sqlresult.
(If the result set is empty) set sqlstate to not found, for example ‘02000’, and return nil.
(If the result set is not empty) set sqlstate to okay, for example ‘00000’, and return true.
(If there was no result set) set sqlstate to okay, for example ‘00000’, and return true.
The job of the function calling sql_execute is to:
Define sqlstate (a string) and define sqlresult (a table) accessible throughout the function.
Call sql_execute with whatever parameters are necessary.
Check what sql_execute returns, if necessary.
Result:
function F()
local sqlstate;
local sqlresult = {};
local sqlmessage;
local function sql_execute(statement, parameters)
--[[not illustrated here, see description]]
end;
do
local I; sql_execute([[SELECT 1;
]],{}); I = sqlresult[1][1];
sql_execute([[
SELECT ? + 3;
]],{I}); return sqlresult[1][1];
end; ::end_8::
end;
For the DEFAULT 1 clause, the function will call on the DBMS to execute “SELECT 1;”, and the result will be in the first column of the first row of sqlresult table, so I = select-result. There are no parameters in this case, which is why ,{} appears.
For the RETURN i + 3 statement, the function will call on the DBMS to execute “SELECT ? + 3;”, and since the ? is a placeholder for a parameter there will have to be a parameter, which is why ,{I} appears. Once again sql_execute() will put the result set, which happens to be one row with one column, in sqlresult. So return sqlresult[1][1] will cause the function to return 4.
Design Decision #6: all expressions will go to SQL for evaluation. Certainly for the example here it would be possible to do the addition in Lua, but when expressions contain SQL functions or operators we have to get SQL to do it. So, for simplicity, I always ask SQL to do it.
Design Decision #7: I’ll assume that sql_execute can’t fail for statements that are assigning, like DEFAULT and RETURN. This isn’t necessarily true, but I figured: if there was something wrong with the expression, it would have failed already.
Getting Out of a block
CREATE LUA PROCEDURE p()
BEGIN
BEGIN
CREATE TABLE t (s1 VARCHAR(4) PRIMARY KEY);
INSERT INTO t VALUES ('a');
INSERT INTO t VALUES ('b');
END;
END;
Adding statements in a BEGIN … END causes the usual sql_execute() calls, but also some goto instructions.
Result:
function P()
local sqlstate;
local sqlresult = {};
local sqlmessage;
local function sql_execute(statement, parameters)
--[[See earlier description.]]
end;
do
do
sql_execute([[
CREATE TABLE t (s1 VARCHAR(4) PRIMARY KEY);
]],{});
if string.sub(sqlstate,1,2) > '02' then goto end_7; end;
sql_execute([[
INSERT INTO t VALUES ('a');
]],{});
if string.sub(sqlstate,1,2) > '02' then goto end_7; end;
sql_execute([[
INSERT INTO t VALUES ('b');
]],{});
end; ::end_7::
end; ::end_6::
end;
The instruction
if string.sub(sqlstate,1,2) > '02' then goto end_7; end;
is my substitute for SQL’s implicit action
“Get out of the BEGIN … END block if there is an error”.
Remember that sql_execute() returns an sqlstate value, and the first two characters of this value must be greater than ’02’ if there is an error. So the goto will go to a point just past the end of the inner Lua do … end block, which is marked by a label ::end_7::. This isn’t necessary for INSERT INTO t VALUES (‘b’); because it is the last thing in the block, so it will pass out of the block anyway.
Design Decision #8: goto is the best way to get out of the block. The alternatives were: (a) use while true … end so that break will get out of the block, as discussed earlier, (b) put “if string.sub(sqlstate,1,2) <= '02'" before every sql_execute() call in the block. Although the alternatives would work in this example, I decided they make the code unreadable when the examples get complicated.
Unconditional Flow control
CREATE LUA PROCEDURE p()
BEGIN
label_1:
LOOP
ITERATE label_1;
LEAVE label_1;
END LOOP;
END;
I can replace SQL’s
LOOP ... END LOOP
with Lua’s
while true ... end
. I can replace SQL’s ITERATE with a goto that goes to just before the end, so that the loop repeats. I can replace SQL’s LEAVE with a goto that goes to just after the end, so that the loop ends.
Result:
function P()
local sqlstate;
local sqlresult = {};
local sqlmessage;
local function sql_execute(statement, parameters)
--[[See earlier description.]]
end;
do
while true do
goto LABEL_1_1;
goto LABEL_1_2;
::LABEL_1_1::end;::LABEL_1_2::
end; ::end_6::
end;
Since the ITERATE-derived “goto LABEL_1_1;” skips past the LEAVE-derived “goto LABEL_1_2;” this is an infinite loop. Its only saving grace is that it is valid Lua code.
Conditional Flow Control
CREATE LUA PROCEDURE p()
BEGIN
DECLARE i INTEGER DEFAULT 1;
WHILE i < 5 DO
INSERT INTO t VALUES (i);
SET i = i + 1;
END WHILE;
END;
WHILE, IF, and REPEAT are statements that depend on a condition. I support them all the same way: by passing "SELECT condition;" to SQL, and then (since such a statement will always return one row with a Boolean value) asking whether the first column in the first row of sqlresult is true.
Result:
function P()
local sqlstate;
local sqlresult = {};
local sqlmessage;
local function sql_execute(statement, parameters)
--[[See earlier description.]]
end;
do
local I; sql_execute([[SELECT 1;
]],{}); I = sqlresult[1][1];
while sql_execute([[
SELECT ? < 5 ;
]],{I}) == true and sqlresult[1][1] == true do
sql_execute([[
INSERT INTO t VALUES (?);
]],{I});
if string.sub(sqlstate,1,2) > '02' then goto end_6; end;
sql_execute([[
SELECT ? + 1;
]],{I})
if string.sub(sqlstate,1,2) > '02' then goto end_6; end;
I = sqlresult[1][1];
end;
end; ::end_6::
end;
We've already seen what the rest of the statements in this loop are supposed to generate, the only new thing is that "SELECT ? < 5;" will return true (because the passed parameter I is less than 5) until I becomes 5 (because "SELECT ? + 1;" is inside the loop).
Design Decision #9: I decided to test first if sql_execute() returns true (that is, does not return an error or not found) before checking whether the value in the result set is true. That's reasonable caution -- but I didn't decide to do a similar test for assignment. That's because a failure during condition evaluation could cause an infinite loop, so it is more serious.
Design Decision #10: I'm saying "SELECT ? < 5;" although I dislike non-standard code -- standard code is "VALUES (? < 5);". This is my concession to what seems to be popular, but I am already regretting it, I probably will change this.
Cursors
CREATE LUA FUNCTION f() RETURNS INTEGER
BEGIN
DECLARE i INTEGER;
BEGIN
DECLARE c CURSOR FOR SELECT 5;
OPEN c;
FETCH c INTO i;
CLOSE c;
END;
RETURN i;
END;
Remember that sql_execute() will put the results of a SELECT into a table named sqlresult. So all I need to do is call sql_execute("SELECT 5;") for the OPEN, pick up a value from sqlresult for the FETCH statement, and rub out sqlresult for the CLOSE statement.
Result:
function F()
local sqlstate;
local sqlresult = {};
local sqlmessage;
local function sql_execute(statement, parameters)
--[[See earlier description.]]
end;
do
local I;
do
local C_CURSOR = {};
local C_CURSOR_OFFSET = 0;
local C_CURSOR_STATUS = 'not open';
C_CURSOR = sql_execute([[
SELECT 5;
]],{});
if string.sub(sqlstate,1,2) > '02' then goto end_13; end;
if string.sub(sqlstate,1,2) == '00' or string.sub(sqlstate,1,2) == '02' then
C_CURSOR_OFFSET = 0;
C_CURSOR_STATUS = 'open';
end;
if C_CURSOR_STATUS ~= 'open' then sqlstate = '07000';
else if C_CURSOR_OFFSET >= #C_CURSOR then sqlstate = '02000';
else do
C_CURSOR_OFFSET = C_CURSOR_OFFSET + 1;
I = C_CURSOR[C_CURSOR_OFFSET][1];
end; end; end;
C_CURSOR= {};
C_CURSOR_OFFSET = 0;
C_CURSOR_STATUS = 'not open';
end; ::end_13::
if string.sub(sqlstate,1,2) > '02' then goto end_8; end;
sql_execute([[
SELECT ?;
]],{I}); return sqlresult[1][1];
end; ::end_8::
end;
Here C_CURSOR is a Lua table with a copy of resultset, and C_CURSOR_OFFSET is something that FETCH can increment whenever it succeeds. FETCH will make its own decision about whether sqlstate = '02000' (which is the SQLSTATE value for NOT FOUND) by checking whether C_CURSOR_OFFSET is greater or equal to the Lua table's size.
Design Decision #11: This is a normal way to get a result set. MySQL/MariaDB users are accustomed to seeing SELECT display results if it is in a routine. I could do the same by looping through sqlresult and calling Lua's print() function, but decided that's not what everyone would expect.
Handlers
CREATE LUA PROCEDURE p()
BEGIN
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
DROP TABLE t;
SIGNAL SQLSTATE '45000'; /* SIGNAL SQLSTATE '45000'; */
END;
I am no longer looking at something easy, because Lua has no equivalent for a handler. I struggled a lot before coming up with the idea of a nested function. After that I struggled a lot more with handlers that have multiple conditions, EXIT handlers, multiple handlers that need to be sorted according to how specific they are, and handlers in blocks that encompass the block that the statement is in. Those complexities are all taken care of now, by generating complex code. Here I'll show only the simplest case.
Result:
do
local function handler_0()
sql_execute([[
DROP TABLE t;
]],{}); end;
sqlstate = '45000';
if string.sub(sqlstate,1,2) > '02' then handler_0(); end;
end; ::end_6::
end;
Here, afer sqlstate = '45000'; which was generated for the SIGNAL statement, we again check to see whether there was an error by looking at sqlstate, but this time, instead of jumping out of the BEGIN/END block when that happens, the function calls handler_0() which has the code generated for DECLARE CONTINUE HANDLER.
Design Decision #12: Defining a function within a function ("nesting" the function) is great, because the generated code ends up in the same relative position that it occupies in the SQL source. However, this makes me depend on a Lua feature. Also, I cannot LEAVE from the handler code into the main code. Nevertheless, the alternative -- putting an indefinite number of conditional goto statements after the handler code -- does not inspire.
Illustration
The following screenshots show a run of the last example, In the second screenshot the code of sql_execute() appears instead of the stub that I've been showing, but it only works with Tarantool. As I said earlier, users have to modify the sql_execute() code to fit their DBMS dialect.
Screenshot #1: showing entry of CREATE LUA PROCEDURE.
Screenshot #2: showing dialog box with result Lua code.
These were done with ocelotgui. I have done no retouching, which is why the indenting is a bit rough. Before entering, I had to ensure that the syntax checker was running ...
SET OCELOT_STATEMENT_SYNTAX_CHECKER = '3';
(Turning on syntax checking invokes the recognizer, without which nothing would work.)
Also, for MySQL/MariaDB only:
SET SESSION SQL_MODE='ansi_quotes';
Limitations
As I said, it's alpha.
Sure, bugs exist and I haven't tested much, because I want to get the design straight, which is why I've focused in this blog post on "Design Decisions". Some particular matters:
CASE, GET, RESIGNAL don't work.
No support for OUT or INOUT parameters.
Only SQL/PSM, not PL/SQL (ocelotgui supports PL/SQL but CREATE LUA does not.)
No handlers within handlers.
No ITERATE or LEAVE to get out of handlers.
Really, this might be useful for any DBMS, even one that doesn't support SQL/PSM, since SQL/PSM is what I took care of. But for a DBMS that we don't support, you'll have to connect to either MySQL/MariaDB or Tarantool and enter generic standard SQL statements, then change to your dialect's SQL statements after you have the Lua function.
Where is this code
I pushed the source code to github.com/ocelot-inc/ocelotgui. It is part of ocelotgui. It has to be part of ocelotgui because we need ocelotgui's recognizer. So anyone wanting to alpha-test would have to:
download the ocelotgui source
build as instructed in the README
start ocelotgui and connect
make sure syntax checking is on, ansi_quotes is off, oracle mode is off
enter a CREATE LUA PROCEDURE or CREATE LUA FUNCTION statement
look at the resulting dialog box
repeat.
The code of the new feature is mostly in file ocelotgui.cpp, function clf().
I want to know whether anyone agrees with the approach. That will affect whether I eventually move the feature to beta.
Comment on this post, or (if the comment period has expired) add a feature request on github/issues, or write to pgulutzan at-sign ocelot.ca.
