How to implement a SQL like LIKE operator in java

Question

I need a comparator in java which has the same semantics as the sql  like  operator  For example   myComparator like  digital    ital     myComparator like  digital    gi a     myComparator like  digital   digi       should evaluate to true  and  myComparator like  digital    cam     myComparator like  digital   tal       should evaluate to false  Any ideas how to implement such a comparator or does anyone know an implementation with the same semantics  Can this be done using a regular expression

User · Answer

i dont know exactly about the greedy issue  but try this if it works for you   public boolean like final String str  String expr          final String   parts   expr split           final boolean traillingOp   expr endsWith           expr           for  int i   0  l   parts length  i  lt  l    i              final String   p   parts i  split                   if  p length  gt  1                  for  int y   0  l2   p length  y  lt  l2    y                      expr    p y             if  i   1  lt  l2  expr                                 else                 expr    parts i                 if  i   1  lt  l  expr                   if  traillingOp  expr             expr   expr replace                expr   expr replace                 return str matches expr

User · Answer

You could turn   string   to contains     string   to startsWith   and   string   to endsWith     You should also run toLowerCase   on both the string and pattern as LIKE is case-insenstive   Not sure how you d handle   string other   except with a Regular Expression though   If you re using Regular Expressions    Quote the string before you replace the   characters Watch out for escaped characters in the LIKE String

User · Answer

public static boolean like String source  String exp            if  source    null    exp    null                return false                     int sourceLength   source length            int expLength   exp length             if  sourceLength    0    expLength    0                return false                     boolean fuzzy   false          char lastCharOfExp   0          int positionOfSource   0           for  int i   0  i  lt  expLength  i                  char ch   exp charAt i                                    boolean escape   false              if  lastCharOfExp                            if  ch           ch                               escape   true                         System out println  escape     ch                                                if   escape  amp  amp  ch                           fuzzy   true                else if   escape  amp  amp  ch                           if  positionOfSource  gt   sourceLength                        return false                                     positionOfSource       lt  lt  lt -----    1               else if  ch                                             if  positionOfSource  gt   sourceLength           source                         return false                                     if  lastCharOfExp                                                int tp   source indexOf ch                          System out println                    ch     position     position     tp     tp                        if  tp    -1                                             return false                                             if  tp  gt   positionOfSource                            positionOfSource   tp   1     lt  lt  lt -----                               if  i    expLength - 1  amp  amp  positionOfSource  lt  sourceLength       exp               source                                      return false                                                  else                           return false                                          else if  source charAt positionOfSource     ch              ch                       positionOfSource                      else                       return false                                               lastCharOfExp   ch     lt  lt  lt -----                   System out println            ch     position     position                         expr                  source           source            if   fuzzy  amp  amp  positionOfSource  lt  sourceLength                   System out println            lastChar     position     position                 return false                     return true        true         Assert assertEquals true  like  abc d    abc   d             Assert assertEquals true  like  abc d    abc    d             Assert assertEquals false  like  abcd    abc   d              String source    1abcd           Assert assertEquals true  like source     d             Assert assertEquals false  like source     a             Assert assertEquals false  like source   1             Assert assertEquals true  like source    d             Assert assertEquals true  like source                    Assert assertEquals true  like source   1               Assert assertEquals false  like source   1  2             Assert assertEquals false  like source   1abcdef             Assert assertEquals true  like source   1abcd             Assert assertEquals false  like source   1abcde                     case              Assert assertEquals true  like source                   Assert assertEquals true  like source                      Assert assertEquals true  like source               5          Assert assertEquals false  like source             3          Assert assertEquals false  like source                 6          Assert assertEquals false  like source   1              Assert assertEquals false  like source   a  b             Assert assertEquals true  like source   1              Assert assertEquals false  like source   d              Assert assertEquals true  like source                  Assert assertEquals true  like source    abc              Assert assertEquals true  like source    d             Assert assertEquals true  like source    abc              Assert assertEquals false  like source   ab                Assert assertEquals true  like source   1ab               Assert assertEquals true  like source   1ab                Assert assertEquals false  like source   1ab                Assert assertEquals true  like source                  Assert assertEquals false  like null   1ab                Assert assertEquals false  like source  null            Assert assertEquals false  like source

User · Answer

Regular expressions are the most versatile  However  some LIKE functions can be formed without regular expressions  e g   String text    digital   text startsWith  dig       like  dig   text endsWith  tal       like   tal  text contains  gita       like   gita

User · Answer

Yes  this could be done with a regular expression  Keep in mind that Java s regular expressions have different syntax from SQL s  like   Instead of      you would have       and instead of      you would have       What makes it somewhat tricky is that you would also have to escape any characters that Java treats as special  Since you re trying to make this analogous to SQL  I m guessing that         shouldn t appear in the regex string  But you will have to replace     with       before doing any other replacements   Edit  Pattern quote String  escapes everything by surrounding the string with   Q  and   E   which will cause everything in the expression to be treated as a literal  no wildcards at all   So you definitely don t want to use it    Furthermore  as Dave Webb says  you also need to ignore case   With that in mind  here s a sample of what it might look like   public static boolean like String str  String expr        expr   expr toLowerCase       ignoring locale for now     expr   expr replace                      is escaped to      thanks  Alan M             escape any other potentially problematic characters here     expr   expr replace                expr   expr replace                 str   str toLowerCase        return str matches expr

User · Answer

Apache Cayanne ORM has an  In memory evaluation    It may not work for unmapped object  but looks promising   Expression exp   ExpressionFactory likeExp  artistName    A        List startWithA   exp filterObjects artists

User · Answer

Ok this is a bit of a weird solution  but I thought it should still be mentioned   Instead of recreating the like mechanism we can utilize the existing implementation already available in any database     Only requirement is  your application must have access to any database     Just run a very simple query each time that returns true or false depending on the result of the like s comparison  Then execute the query  and read the answer directly from the database   For Oracle db   SELECT CASE       WHEN  StringToSearch  LIKE  LikeSequence  THEN  true       ELSE  false   END test FROM dual    For MS SQL Server  SELECT CASE       WHEN  StringToSearch  LIKE  LikeSequence  THEN  true       ELSE  false  END test   All you have to do is replace  StringToSearch  and  LikeSequence  with bind parameters and set the values you want to check

User · Answer

This s my take on this  it s in Kotlin but can be converted to Java with little effort  val percentageRegex   Regex  quot  quot  quot    lt       quot  quot  quot   val underscoreRegex   Regex  quot  quot  quot    lt       quot  quot  quot    infix fun String like predicate  String   Boolean          Split the text by every   not preceded by a slash        We transform each slice before joining them with    as a separator      return predicate split percentageRegex  joinToString  quot    quot     percentageSlice - gt             Split the text by every   not preceded by a slash            We transform each slice before joining them with   as a separator          percentageSlice split underscoreRegex  joinToString  quot   quot     underscoreSlice - gt                 Each slice is wrapped in  quot Regex quotes quot  to ignore all                the metacharacters they contain                We also remove the slashes from the escape sequences                since they are now treated literally              Pattern quote                  underscoreSlice replace  quot     quot    quot   quot   replace  quot     quot    quot   quot                                  let    quot   it  quot    toRegex   matches this like     It might not be the most performant of all the solutions here  but it s probably the most accurate  It ignores all the other Regex metacharacters other than   and   and also supports escaping them with a slash

User · Answer

Check out https   github com hrakaroo glob-library-java     It s a zero dependency library in Java for doing glob  and sql like  type of comparisons   Over a large data set it is faster than translating to a regular expression   Basic syntax   MatchingEngine m   GlobPattern compile  dog cat  goat              GlobPattern HANDLE ESCAPES   if  m matches str

User · Answer

will match any characters in regular expressions  I think the java syntax would be   digital  matches    ital        And for the single character match just use a single dot    digital  matches    gi a        And to match an actual dot  escape it as slash dot

User · Answer

http   josql sourceforge net  has what you need  Look for org josql expressions LikeExpression

User · Answer

Every SQL reference I can find says the  any single character  wildcard is the underscore      not the question mark       That simplifies things a bit  since the underscore is not a regex metacharacter   However  you still can t use Pattern quote   for the reason given by mmyers   I ve got another method here for escaping regexes when I might want to edit them afterward   With that out of the way  the like   method becomes pretty simple   public static boolean like final String str  final String expr      String regex   quotemeta expr     regex   regex replace           replace                Pattern p   Pattern compile regex        Pattern CASE INSENSITIVE   Pattern DOTALL     return p matcher str  matches       public static String quotemeta String s      if  s    null          throw new IllegalArgumentException  String cannot be null           int len   s length      if  len    0          return            StringBuilder sb   new StringBuilder len   2     for  int i   0  i  lt  len  i            char c   s charAt i       if                     indexOf c     -1              sb append                  sb append c         return sb toString        If you really want to use   for the wildcard  your best bet would be to remove it from the list of metacharacters in the quotemeta   method   Replacing its escaped form -- replace             -- wouldn t be safe because there might be backslashes in the original expression   And that brings us to the real problems  most SQL flavors seem to support character classes in the forms  a-z  and   j-m  or   j-m   and they all provide a way to escape wildcard characters   The latter is usually done by means of an ESCAPE keyword  which lets you define a different escape character every time   As you can imagine  this complicates things quite a bit   Converting to a regex is probably still the best option  but parsing the original expression will be much harder--in fact  the first thing you would have to do is formalize the syntax of the LIKE-like expressions themselves

User · Answer

Java strings have  startsWith   and  contains   methods which will get you most of the way  For anything more complicated you d have to use regex or write your own method

User · Answer

To implement  LIKE functions of sql  in java you don t need regular expression in  They can be obtained as   String text    apple   text startsWith  app       like  app   text endsWith  le       like   le  text contains  ppl       like   ppl

User · Answer

The Comparator and Comparable interfaces are likely inapplicable here  They deal with sorting  and return integers of either sign  or 0  Your operation is about finding matches  and returning true false  That s different

User · Answer

public static boolean like String toBeCompare  String by       if by    null           if toBeCompare    null               if by startsWith       amp  amp  by endsWith                        int index   toBeCompare toLowerCase   indexOf by replace          toLowerCase                     if index  lt  0                       return false                    else                       return true                                  else if by startsWith                        return toBeCompare endsWith by replace                          else if by endsWith                        return toBeCompare startsWith by replace                          else                   return toBeCompare equals by replace                                    else               return false                  else           return false            may be help you

[java] How to implement a SQL like 'LIKE' operator in java?

Examples related to java

Examples related to sql

Examples related to regex

Examples related to string

Examples related to wildcard