MySQL - 搜索模式

Question

I'm trying to figure out if someone has an elegant way to look for patterns in data stored in a varchar field where a value is not known -- meaning I can't use LIKE. For example, say a table called test looked like this:

id, str

and the data looked like this:

1, YUUUY
2, DDDMM
3, MMMMT
4, XMXMX

and I want to do a select that will return anything where the value of str has a pattern that matches the pattern ABABA. ABABA here shows a pattern and not literal letters. So the only one that matches this pattern would be id = 4. Is there a regular expression that I can use to pattern match like this? To make sure I'm clear regarding the patterns:

The pattern for id=1 is ABBBA.  
The pattern for id=2 is AAABB.  
The pattern for id=3 is AAAAB.

When running the query, all I will know is the pattern to search for.

Alternatively, if it makes it easier, I can have the table set up like:

id,c1,c2,c3,c4,c5

and the data would look like this:

1,Y,U,U,U,Y
2,D,D,D,M,M
3,M,M,M,M,T
4,X,M,X,M,X

Not sure if that makes it easier, but I think regexp is out the window if the data is set up like that.

Answer 1

Unfortunately, it doesn't look like MySQL supports regex groups. I was hoping you could do something like this to match ABBBA for example:

([A-Z])([A-Z])\2\2\1

Example here: http://regexr.com/3d8gu

It looks like there is a MySQL plugin that might support it:

https://github.com/mysqludf/lib_mysqludf_preg

Here is a real hacky way to do it.

ABBBA (or YUUUY, etc):

SELECT id, name FROM table WHERE    
  substring(name,1,1) = substring(name,5,1) AND      
  substring(name,2,1) = substring(name,3,1) AND
  substring(name,3,1) = substring(name,4,1);

AAABB (or DDDMM, etc):

SELECT id, name FROM table WHERE    
  substring(name,1,1) = substring(name,2,1) AND      
  substring(name,2,1) = substring(name,3,1) AND
  substring(name,4,1) = substring(name,5,1);

AAAAB (or MMMMT, etc):

SELECT id, name FROM table WHERE    
  substring(name,1,1) = substring(name,2,1) AND      
  substring(name,2,1) = substring(name,3,1) AND
  substring(name,3,1) = substring(name,4,1) AND
  substring(name,4,1) != substring(name,5,1);

You get the picture...

It would be similar if you separated the data into different columns. Instead of comparing substrings you would just compare the columns.

Answer 2

No regular expression support in MySQL to do that kind of pattern matching, no.

SQL wasn't specifically designed for pattern matching of strings (or patterns of values in separate columns.)

But... we could come up with something workable, even if it's not a regular expression and it's not elegant.

Assuming we don't have a custom built user-defined function, and we want to use native MySQL functions and expression...

And assuming that the patterns we are looking for are guaranteed to consist of only two distinct characters...

And assuming that we're looking at exactly five character positions...

And assuming that the pattern string we're matching to will always begin with the letter 'A', and the "other" letter in the pattern will also be 'B'

It wouldn't be overly ugly to do something like this:

SELECT t.id
     , t.str
  FROM myable t         
WHERE CONCAT('A'
        ,IF(MID(t.str,2,1)=MID(t.str,1,1),'A','B')
        ,IF(MID(t.str,3,1)=MID(t.str,1,1),'A','B')
        ,IF(MID(t.str,4,1)=MID(t.str,1,1),'A','B')
        ,IF(MID(t.str,5,1)=MID(t.str,1,1),'A','B')
      ) = 'ABBBA'

The first character in the string is automatically converted to an 'A'.

The second character, if that matches the first character, then it's also an 'A' otherwise it's a 'B'.

We do the same thing for the third, fourth and fifth characters.

Concatenate the 'A' and 'B' characters into a single string, and we can now perform an equality comparison to a pattern string, consisting of 'A' and 'B', starting with an 'A'.

But that is going to fall apart if the stated assumptions aren't true. If str is less than five characters in length, if it contains more than two distinct characters (we'll see the first character as matching... this would see str=XYYZX as matching pattern ABBBA. (First character is automatic match to A, and the fifth character matches the first, so it's an A, and all of the other characters don't match, so they are 'B', even though they aren't the same.

And so on.

We could add some additional checks.

For example, to guaranteed that str is exactly five characters in length...

AND CHAR_LENGTH(t.str)=5

Note that the default collation in MySQL is case insensitive. That means means a str value of MmmmM would be converted to 'AAAAA', not 'ABBBA'. And a str value of MmmKk would match 'AAABB'.