Skip to content

# Tag: SQL

## Some observations on MySQL to sqlite migration & compatibility

MySQL SQL sqlite January 30, 2017January 30, 2017

I’m experimenting with sqlite as backend database for orchestrator. While `orchestrator` manages MySQL replication topologies, it also uses MySQL as backend. For some deployments, and I’m looking into such one, having MySQL as backend is a considerable overhead.

This sent me to the route of looking into a self contained `orchestrator` binary + backend DB. I would have `orchestrator` spawn up its own backend database instead of connecting to an external one.

### Why even relational?

Can’t `orchestrator` just use a key-value backend?

Maybe it could. But frankly I enjoy the power of relational databases, and the versatility they offer has proven itself multiple times with `orchestrator`, being able to answer interesting, new, complex questions about one’s topology by crafting SQL queries.

Moreover, `orchestrator` is already heavily invested in the relational model. At this time, replacing all SQL queries with key-value reads seems to me as a significant investment in time and risk. So I was looking for a relational, SQL accessible embeddable database for `orchestrator`.

### Why sqlite?

I am in particular looking at two options: sqlite (via the go-sqlite3 binding) and TiDB. sqlite does not need much introduction, and I’ll just say it’s embeddable within the golang-built binary. Continue reading » “Some observations on MySQL to sqlite migration & compatibility”

## Three wishes for a new year

MySQL gh-ost GTID operations Opinions Replication SQL September 28, 2016

(Almost) another new year by Jewish calendar. What do I wish for the following year?

1. World peace
2. Good health to all
3. Relaxed GTID constraints

I’m still not using GTID, and still see operational issues with working with GTID. As a latest example, our new schema migration solution, gh-ost, allows us to test migrations in production, on replicas. The GTID catch? `gh-ost` has to write something to the binary log. Thus, it “corrupts” the replica with a bogus GTID entry that will never be met in another server, thus making said replica unsafe to promote. We can work around this, but…

I understand the idea and need for the `Executed GTID Set`. It will certainly come in handy with multi-writer InnoDB Cluster. However for most use cases GTID poses a burden. The reason is that our topologies are imperfect, and we as humans are imperfect, and operations are most certainly imperfect. We may wish to operate on a replica: test something, by intention or mistake. We may wish to use a subchain as the seed for a new cluster split. We may wish to be able to write to downstream replicas. We may use a 3rd party tool that issues a `flush tables with read lock` without disabling `sql_log_bin`. Things just happen.

For that, I would like to suggest GTID control levels, such as:

1. Strict: same as Oracle’s existing implementation. Executed sets, purged sets, whatnot.
2. Last executed: a mode where the only thing that counts is the last executed GTID value. If I repoint replica, all it needs to check is “hey this is my last executed GTID entry, give me the coordinates of yours. And, no, I don’t care about comparing executed and purged sets, I will trust you and keep running from that point on”
3. Declarative: GTIDs are generated, are visible in each and every binary log entry, but are completely ignored.

I realize Oracle MySQL GTID is out for some over 3 years now, but I’m sorry – I still have reservations and see use cases where I fear it will not serve me right.

How about my previous years wishes? World peace and good health never came through, however:

- My 2015 wish for “decent, operations friendly built in online table refactoring” was unmet, however `gh-ost` is a thing now and exceeds my expectations. No, really. Please come see Tom & myself present gh-ost and how it changed our migration paradigm.
- My 2012 wish for “decent, long waited for, implementation of Window Functions (aka Analytic Functions) for MySQL” was met by MariaDB’s window functions.
  Not strictly Window Functions, but Oracle MySQL 8.0 will support CTE (hierarchial/recursive), worth a mention.

See you in Amsterdam!

## SQL mini hack of the day, inverted IN clause

MySQL SQL November 13, 2015

We are used to issue queries with an IN clause of the form:

>     ... where state in ('started', 'completed', 'failed') ...

However I’ve had a few cases where I used an inverted format. Here’s one use case followed by an inverted IN clause.

### Dynamic query building

Say we have this function:

> GetLaggingSlaves(clusterName string)

Which, based on whether given clusterName is empty or not, would return list of all lagging slaves, or only those in the given cluster, respectively: Continue reading » “SQL mini hack of the day, inverted IN clause”

## Leader election using MySQL

MySQL SQL October 14, 2015March 25, 2019

Being a stateful, centralized datastore, MySQL can serve in negotiating leadership: a mechanism to elect a single service out of multiple services; moreover, a mechanism to promote a new leader should the existing leader cease to function.

### What of Zookeeper?

Zookeeper makes for an excellent leader election mechanism. This is one of the most recognized uses for Zookeeper. It has HA via multiple nodes & quorum, ephemeral nodes, all you need. To achieve similar benefits with MySQL you’d need to use Galera or NDB Cluster; so why not use Zk? The use case at hand is

orchestrator, a multi-node, mostly stateless service that happens to use MySQL as backend datastore. Ir relies on MySQL to exist in backend. It already expects it to be there. If the MySQL server is down, so is the service, effectively. In such case it doesn’t hurt adding another dependency on MySQL; this does not reduce HA. You need to take care of MySQL HA anyhow so there’s no additional cost. In fact, going to Zookeeper makes the additional cost as you introduce a new component to the system that can be avoided.

### Terms of the solution

Our proposed solution offers:

- Single leader election out of multiple nodes
- Leader actively reaffirms its leadership periodically
- Timeout based re-election: decision to re-elect new leader based on the fact current leader has not reaffirmed its leadership over X seconds
- A way to forcibly assume leadership for a specific node
- A way to forcibly call for re-elections by demoting existing leader
- A node/service can easily tell whether it’s the leader or not
- Anyone can tell who the leader is

### SQL solution

The solution is composed of a single table and a set of queries which implement the above offers. We assume a service can uniquely identify itself; this is easy to achieve:

- If services are running from different hosts (as should be the case, this is service HA), use hostname for ID
  - But what if the service restarts? Are you good with calling this “the same service” or is this now a new service running on the same host?
- In such case use combination of hostname & OS process ID
  - Or generate a random token upon startup
  - Or use startup timestamp Whichever solution you pick, make sure it is human readable, such that it is easy to tell

which service is the leader. This helps operations. We note this as service_id

#### Table

The following table will have a single row; the

service_id in that row is the active leader.

    CREATE TABLE service_election (
      anchor tinyint(3) unsigned NOT NULL,
      service_id varchar(128) NOT NULL,
      last_seen_active timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
      PRIMARY KEY (anchor)
    ) ENGINE=InnoDB

#### Attempt election

Continue reading » “Leader election using MySQL”

## Tool of the day: q

Linux MySQL command line Open Source SQL tools August 8, 2013August 8, 2013

If you work with command line and know your SQL, q is a great tool to use:

q allows you to query your text files or standard input with SQL. You can:

>     SELECT c1, COUNT(*) FROM /home/shlomi/tmp/my_file.csv GROUP BY c1

And you can:

>     SELECT all.c2 FROM /tmp/all_engines.txt AS all LEFT JOIN /tmp/innodb_engines.txt AS inno USING (c1, c2) WHERE inno.c3 IS NULL

And you can also combine with your favourite shell commands and tools:

>     grep "my_term" /tmp/my_file.txt | q "SELECT c4 FROM - JOIN /home/shlomi/static.txt USING (c1)" | xargs touch

Some of q‘s functionality (and indeed, SQL functionality) can be found in command line tools. You can use grep for pseudo WHERE filtering, or cut for projecting, but you can only get so far with cat my_file.csv | sort | uniq -c | sort -n. SQL is way more powerful for working with tabulated data, and so q makes for a great addition into one’s toolbox.

The tool is authored by my colleague Harel Ben-Attia, and is in daily use over at our company (it is in fact installed on all production servers).

It is of course free and open source (get it on GitHub, where you can also find documentation), and very easy to setup. Enjoy!

## Merging tables with INSERT…ON DUPLICATE KEY UPDATE

MySQL SQL Syntax February 21, 2013

Had a case recently where I had to merge data from two identically structured tables containing nearly identical data.

“Nearly identical” meaning most table data is identical in both; sometimes a row is missing from one of the tables; sometimes same row (according to PK) appears in both, but some columns are NULL is one tables (while others can be NULL in the second).

Otherwise no contradicting data: it was not possible for some data to be “3” in one table and “4” in the other.

#### How do you create a merge of the tables, such that all missing rows are completed, and NULLs replaced by actual values when possible?

pt-table-sync comes to mind: one can do a bidirectional syncing of two tables, and actually stating how to resolve ambiguities (like “greater value wins”). Very powerful! An example would be:

>     pt-table-sync --bidirectional --conflict-column=a --conflict-comparison=greatest --tables ...

However I didn’t actually have any problem with the tables themselves. The two tables were just fine as they were; missing or NULL data does not indicate an error on their part. I wanted to get their merge. pt-table-sync is still up for the job: we can duplicate them, merge on the copy… But I prefer a query over an external script when possible.

#### INSERT…ON DUPLICATE KEY UPDATE

This MySQL-specific syntax is actually quite powerful. It basically says “if the insert fails due to unique constraint, you get a chance to update the row causing the failure”. But it also allows for smart setting of the column via the VALUES() clause. Let’s present some sample data and then see the solution. Continue reading » “Merging tables with INSERT…ON DUPLICATE KEY UPDATE”

## Hierarchical data in INFORMATION_SCHEMA and derivatives

MySQL INFORMATION_SCHEMA SQL January 8, 2013

Just how often do you encounter hierarchical data? Consider a table with some parent-child relation, like the this classic employee table:

>     CREATE TABLE employee (
>       employee_id INT UNSIGNED PRIMARY KEY,
>       employee_name VARCHAR(100),
>       manager_id INT UNSIGNED,
>       CONSTRAINT `employee_manager_fk` FOREIGN KEY (manager_id) REFERENCES employee (employee_id)
>     ) engine=innodb
>     ;
>     +-------------+---------------+------------+
>     | employee_id | employee_name | manager_id |
>     +-------------+---------------+------------+
>     |           1 | Rachel        |       NULL |
>     |           2 | John          |          1 |
>     |           3 | Stan          |          1 |
>     |           4 | Naomi         |          2 |
>     +-------------+---------------+------------+

Questions like “What is the (nested) list of employees managed by Rachel?” or “Get Naomi’s managers chain of command” are classical questions. There are sometimes dependencies: if John leaves, does that mean Naomi loses her job, or does she get promoted, or something else? If John and Stan are on sick leave, does Rachel have any reason to come to work?

Hierarchical data is not limited to a single-table structure. Sometimes it takes a combination of a few tables (it’s just a JOIN) to make out the parent-child relation.

Hierarchical data is difficult to manage with SQL. This is especially true for MySQL, which does not support the WITH recursive query syntax.

#### Where can you find hierarchical data?

Even if you do not provide it by yourself, MySQL’s INFORMATION_SCHEMA has some for you. Partly obvious, partly implicit, here are some examples: Continue reading » “Hierarchical data in INFORMATION_SCHEMA and derivatives”

## Pop quiz: funny syntax

MySQL SQL Syntax November 5, 2012

The following questions are of little importance, yet I find them entertaining. I stumbled upon these while developing QueryScript.

Can you guess the results of the following statements?

#### Pop quiz 1

>     SET @x := 7;
>     SELECT ++@x;

What is the computation result? What will be the value of @x?

#### Pop quiz 2

>     SET @ := 4;
>     SELECT @ + @'' + @``

What is the computation result?

#### Pop quiz 3

>     SET @a := 2;
>     SELECT @a = @'a' = @`a`

Do we get TRUE or FALSE? When? Continue reading » “Pop quiz: funny syntax”

## Three wishes for a new year

MySQL SQL September 16, 2012

Another new year by Jewish calendar. What do I wish for the following year?

1. World peace
2. Good health to all
3. Get a decent, long waited for, implementation of Window Functions (aka Analytic Functions) for MySQL.

I mean, I like GROUP_CONCAT, and the many hacks it provides: [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12]. But it makes for a poor substitution to Window Functions, and only solves a subset of issues.

My wishes in previous two years [2010], [2011] have not come true. I’m still willing to settle for two out of three.

## SQL: selecting top N records per group, another solution

MySQL Hack SQL August 21, 2012August 21, 2012

A while back I presented SQL: selecting top N records per group, a “give me the top 5 countries in each continent” type of query, and which used an external numbers table and a lot of tedious casting.

Here’s another solution I came up with (*). Still using GROUP_CONCAT (how else?), but no external table and no casting. The query outputs the largest 5 countries (by surface area) per continent.

>     SELECT
>       Continent,
>       Name,
>       SurfaceArea,
>       Population
>     FROM
>       world.Country,
>       (
>         SELECT
>           GROUP_CONCAT(top_codes_per_group) AS top_codes
>         FROM
>           (
>             SELECT
>               SUBSTRING_INDEX(GROUP_CONCAT(Code ORDER BY SurfaceArea DESC), ',', 5) AS top_codes_per_group
>             FROM
>               world.Country
>             GROUP BY
>               Continent
>           ) s_top_codes_per_group
>       ) s_top_codes
>     WHERE
>       FIND_IN_SET(Code, top_codes)
>     ORDER BY
>       Continent,
>       SurfaceArea DESC
>     ;

>     +---------------+----------------------------------------------+-------------+------------+
>     | Continent     | Name                                         | SurfaceArea | Population |
>     +---------------+----------------------------------------------+-------------+------------+
>     | Asia          | China                                        |  9572900.00 | 1277558000 |
>     | Asia          | India                                        |  3287263.00 | 1013662000 |
>     | Asia          | Kazakstan                                    |  2724900.00 |   16223000 |
>     | Asia          | Saudi Arabia                                 |  2149690.00 |   21607000 |
>     | Asia          | Indonesia                                    |  1904569.00 |  212107000 |
>     | Europe        | Russian Federation                           | 17075400.00 |  146934000 |
>     | Europe        | Ukraine                                      |   603700.00 |   50456000 |
>     | Europe        | France                                       |   551500.00 |   59225700 |
>     | Europe        | Spain                                        |   505992.00 |   39441700 |
>     | Europe        | Sweden                                       |   449964.00 |    8861400 |
>     | North America | Canada                                       |  9970610.00 |   31147000 |
>     | North America | United States                                |  9363520.00 |  278357000 |
>     | North America | Greenland                                    |  2166090.00 |      56000 |
>     | North America | Mexico                                       |  1958201.00 |   98881000 |
>     | North America | Nicaragua                                    |   130000.00 |    5074000 |
>     | Africa        | Sudan                                        |  2505813.00 |   29490000 |
>     | Africa        | Algeria                                      |  2381741.00 |   31471000 |
>     | Africa        | Congo, The Democratic Republic of the        |  2344858.00 |   51654000 |
>     | Africa        | Libyan Arab Jamahiriya                       |  1759540.00 |    5605000 |
>     | Africa        | Chad                                         |  1284000.00 |    7651000 |
>     | Oceania       | Australia                                    |  7741220.00 |   18886000 |
>     | Oceania       | Papua New Guinea                             |   462840.00 |    4807000 |
>     | Oceania       | New Zealand                                  |   270534.00 |    3862000 |
>     | Oceania       | Solomon Islands                              |    28896.00 |     444000 |
>     | Oceania       | New Caledonia                                |    18575.00 |     214000 |
>     | Antarctica    | Antarctica                                   | 13120000.00 |          0 |
>     | Antarctica    | French Southern territories                  |     7780.00 |          0 |
>     | Antarctica    | South Georgia and the South Sandwich Islands |     3903.00 |          0 |
>     | Antarctica    | Heard Island and McDonald Islands            |      359.00 |          0 |
>     | Antarctica    | Bouvet Island                                |       59.00 |          0 |
>     | South America | Brazil                                       |  8547403.00 |  170115000 |
>     | South America | Argentina                                    |  2780400.00 |   37032000 |
>     | South America | Peru                                         |  1285216.00 |   25662000 |
>     | South America | Colombia                                     |  1138914.00 |   42321000 |
>     | South America | Bolivia                                      |  1098581.00 |    8329000 |
>     +---------------+----------------------------------------------+-------------+------------+

In bold are the conditions by which we nominate our selected rows (condition is SurfaceArea DESC, number of rows is 5, so 5 largest countries).

#### Continue reading » “SQL: selecting top N records per group, another solution”