content: {-|
  Module: Squeal.PostgreSQL.Expression.Text
  Description: text functions and operators
  Copyright: (c) Eitan Chatav, 2019
  Maintainer: eitan@morphism.tech
  Stability: experimental
  
  text functions and operators
  -}
  
  {-# LANGUAGE
      DataKinds
    , OverloadedStrings
    , RankNTypes
    , ScopedTypeVariables
    , TypeOperators
  #-}
  
  module Squeal.PostgreSQL.Expression.Text
    ( -- * Text Function
      lower
    , upper
    , charLength
    , like
    , ilike
    , replace
    , strpos
    ) where
  
  import Squeal.PostgreSQL.Expression
  import Squeal.PostgreSQL.Type.Schema
  
  -- $setup
  -- >>> import Squeal.PostgreSQL
  
  -- | >>> printSQL $ lower "ARRRGGG"
  -- lower((E'ARRRGGG' :: text))
  lower :: null 'PGtext --> null 'PGtext
  lower = unsafeFunction "lower"
  
  -- | >>> printSQL $ upper "eeee"
  -- upper((E'eeee' :: text))
  upper :: null 'PGtext --> null 'PGtext
  upper = unsafeFunction "upper"
  
  -- | >>> printSQL $ charLength "four"
  -- char_length((E'four' :: text))
  charLength :: null 'PGtext --> null 'PGint4
  charLength = unsafeFunction "char_length"
  
  -- | The `like` expression returns true if the @string@ matches
  -- the supplied @pattern@. If @pattern@ does not contain percent signs
  -- or underscores, then the pattern only represents the string itself;
  -- in that case `like` acts like the equals operator. An underscore (_)
  -- in pattern stands for (matches) any single character; a percent sign (%)
  -- matches any sequence of zero or more characters.
  --
  -- >>> printSQL $ "abc" `like` "a%"
  -- ((E'abc' :: text) LIKE (E'a%' :: text))
  like :: Operator (null 'PGtext) (null 'PGtext) ('Null 'PGbool)
  like = unsafeBinaryOp "LIKE"
  
  -- | The key word ILIKE can be used instead of LIKE to make the
  -- match case-insensitive according to the active locale.
  --
  -- >>> printSQL $ "abc" `ilike` "a%"
  -- ((E'abc' :: text) ILIKE (E'a%' :: text))
  ilike :: Operator (null 'PGtext) (null 'PGtext) ('Null 'PGbool)
  ilike = unsafeBinaryOp "ILIKE"
  
  -- | Determines the location of the substring match using the `strpos`
  -- function. Returns the 1-based index of the first match, if no
  -- match exists the function returns (0).
  --
  -- >>> printSQL $ strpos ("string" *: "substring")
  -- strpos((E'string' :: text), (E'substring' :: text))
  strpos
    :: '[null 'PGtext, null 'PGtext] ---> null 'PGint4
  strpos = unsafeFunctionN "strpos"
  
  -- | Over the string in the first argument, replace all occurrences of
  -- the second argument with the third and return the modified string.
  --
  -- >>> printSQL $ replace ("string" :* "from" *: "to")
  -- replace((E'string' :: text), (E'from' :: text), (E'to' :: text))
  replace
    :: '[ null 'PGtext, null 'PGtext, null 'PGtext ] ---> null 'PGtext
  replace = unsafeFunctionN "replace"
  