Строки

Функция	Описание
BIT_LENGTH	Возвращает длину входной строки в битах.
CONCAT	Объединяет все входные выражения в строку.
CONCAT_WS	Объединяет все входные выражения в строку, разделяя их указанным разделителем.
DATE	Преобразует строку с датой в заданном формате в значение типа Date.
ENDS_WITH	Возвращает True, если значение заканчивается вторым аргументом.
INITCAP	Преобразует первую букву каждого слова в прописную, а остальные — в строчные.
LEFT	Возвращает первые (самые левые) `n` символов.
LENGTH	Возвращает количество символов в строке.
LOWER	Возвращает столбец, преобразованный в нижний регистр.
LPAD	Дополняет строку слева до заданной длины, используя необязательный символ заполнения (по умолчанию — пробел).
LTRIM	Удаляет пробельные символы слева.
NORMALIZE	Преобразует строку в указанную форму нормализации Unicode (одну из NFC, NFD, NFKC, NFKD).
OCTET_LENGTH	Возвращает длину заданной строки в байтах.
POSITION	Возвращает позицию подстроки в строке.
REGEXP_LIKE	Возвращает True, если `pattern` соответствует значению (необязательно: `flags`).
REPLACE	Заменяет заданную подстроку другой строкой.
REVERSE	Возвращает строку в обратном порядке.
RIGHT	Возвращает последние (самые правые) `n` символов.
RPAD	Дополняет строку справа до заданной длины, используя необязательный символ заполнения (по умолчанию — пробел).
RTRIM	Удаляет пробельные символы справа.
SPLIT_PART	Разбивает строку по другой подстроке/разделителю и возвращает часть с номером `n`; обратите внимание, что `n` нумеруется с 1.
STARTS_WITH	Возвращает True, если значение начинается со второго аргумента.
STRING_TO_ARRAY	Разбивает строку по другой подстроке/разделителю и возвращает массив строк.
STRPOS	Возвращает индекс заданной подстроки в целевой строке; обратите внимание, что индексация начинается с 1 (значение 0 означает, что заданная строка не найдена).
STRPTIME	Преобразует строку в Datetime, используя строку формата, совместимую со strftime.
SUBSTR, SUBSTRING	Возвращает фрагмент строковых данных (начиная с заданного индекса, с необязательной длиной); обратите внимание, что `start` нумеруется с 1.
TIMESTAMP	Преобразует строку с временной меткой/датой и временем в заданном формате в значение типа Datetime.
TRIM	Удаляет символы слева и/или справа от строки.
UPPER	Возвращает столбец, преобразованный в верхний регистр.

BIT_LENGTH

Возвращает длину входной строки в битах.

Пример:

df = pl.DataFrame({"foo": ["a", "bb", "ccc", "dddd"]})
df.sql("""
  SELECT foo, BIT_LENGTH(foo) AS n_bits FROM self
""")
# shape: (4, 2)
# ┌──────┬────────┐
# │ foo  ┆ n_bits │
# │ ---  ┆ ---    │
# │ str  ┆ u32    │
# ╞══════╪════════╡
# │ a    ┆ 8      │
# │ bb   ┆ 16     │
# │ ccc  ┆ 24     │
# │ dddd ┆ 32     │
# └──────┴────────┘

CONCAT

Объединяет все входные выражения в строку.

Пример:

df = pl.DataFrame(
  {
    "foo": ["aa", "b", "c", "dd"],
    "bar": ["zz", "yy", "xx", "ww"],
  }
)
df.sql("""
  SELECT CONCAT(foo, bar) AS foobar FROM self
""")
# shape: (4, 1)
# ┌────────┐
# │ foobar │
# │ ---    │
# │ str    │
# ╞════════╡
# │ aazz   │
# │ byy    │
# │ cxx    │
# │ ddww   │
# └────────┘

CONCAT_WS

Объединяет все входные выражения в строку, разделяя их указанным разделителем.

Пример:

df = pl.DataFrame(
  {
    "foo": ["aa", "b", "c", "dd"],
    "bar": ["zz", "yy", "xx", "ww"],
  }
)
df.sql("""
  SELECT CONCAT_WS(':', foo, bar) AS foobar FROM self
""")
# shape: (4, 1)
# ┌────────┐
# │ foobar │
# │ ---    │
# │ str    │
# ╞════════╡
# │ aa:zz  │
# │ b:yy   │
# │ c:xx   │
# │ dd:ww  │
# └────────┘

DATE

Преобразует строку с датой в заданном формате в значение типа Date; по умолчанию используется формат ISO-8601, если во втором параметре не указана строка формата, совместимая со strftime.

Совет

DATE также поддерживается в качестве типизированного литерала (эта форма не позволяет указать строку формата).

SELECT DATE '2021-01-01' AS dt

Пример:

df = pl.DataFrame(
  {
    "s_dt1": ["1969-10-30", "2024-07-05", "2077-02-28"],
    "s_dt2": ["10 February 1920", "5 July 2077", "28 April 2000"],
  }
)
df.sql("""
  SELECT
    DATE(s_dt1) AS dt1,
    DATE(s_dt2, '%d %B %Y') AS dt2
  FROM self
""")
# shape: (3, 2)
# ┌────────────┬────────────┐
# │ dt1        ┆ dt2        │
# │ ---        ┆ ---        │
# │ date       ┆ date       │
# ╞════════════╪════════════╡
# │ 1969-10-30 ┆ 1920-02-10 │
# │ 2024-07-05 ┆ 2077-07-05 │
# │ 2077-02-28 ┆ 2000-04-28 │
# └────────────┴────────────┘

ENDS_WITH

Возвращает True, если значение заканчивается вторым аргументом.

Пример:

df = pl.DataFrame(
  {
    "foo": ["aa", "bb", "cc", "dd"],
    "bar": ["zz", "yy", "xx", "ww"],
  }
)
df.sql("""
  SELECT foo, ENDS_WITH(foo, 'a') AS ends_a FROM self
""")
# shape: (4, 2)
# ┌─────┬────────┐
# │ foo ┆ ends_a │
# │ --- ┆ ---    │
# │ str ┆ bool   │
# ╞═════╪════════╡
# │ aa  ┆ true   │
# │ bb  ┆ false  │
# │ cc  ┆ false  │
# │ dd  ┆ false  │
# └─────┴────────┘

INITCAP

Преобразует первую букву каждого слова в прописную, а остальные — в строчные.

Пример:

df = pl.DataFrame({"bar": ["hello world", "HELLO", "wOrLd"]})
df.sql("""
  SELECT bar, INITCAP(bar) AS baz FROM self
""")
# shape: (3, 2)
# ┌─────────────┬─────────────┐
# │ bar         ┆ baz         │
# │ ---         ┆ ---         │
# │ str         ┆ str         │
# ╞═════════════╪═════════════╡
# │ hello world ┆ Hello World │
# │ HELLO       ┆ Hello       │
# │ wOrLd       ┆ World       │
# └─────────────┴─────────────┘

LEFT

Возвращает первые (самые левые) n символов.

Пример:

df = pl.DataFrame(
  {
    "foo": ["abcd", "efgh", "ijkl", "mnop"],
    "bar": ["zz", "yy", "xx", "ww"],
  }
)
df.sql("""
  SELECT
    LEFT(foo, 1) AS foo1,
    LEFT(bar, 2) AS bar2
  FROM self
""")

# shape: (4, 2)
# ┌──────┬──────┐
# │ foo1 ┆ bar2 │
# │ ---  ┆ ---  │
# │ str  ┆ str  │
# ╞══════╪══════╡
# │ a    ┆ zz   │
# │ e    ┆ yy   │
# │ i    ┆ xx   │
# │ m    ┆ ww   │
# └──────┴──────┘

LENGTH

Возвращает количество символов в строке.

Псевдонимы

CHAR_LENGTH, CHARACTER_LENGTH

Пример:

df = pl.DataFrame(
  {
    "iso_lang":["de", "ru", "es"],
    "color": ["weiß", "синий", "amarillo"],
  }
)
df.sql("""
  SELECT
    iso_lang,
    color,
    LENGTH(color) AS n_chars,
    OCTET_LENGTH(color) AS n_bytes
  FROM self
""")

# shape: (3, 4)
# ┌──────────┬──────────┬─────────┬─────────┐
# │ iso_lang ┆ color    ┆ n_chars ┆ n_bytes │
# │ ---      ┆ ---      ┆ ---     ┆ ---     │
# │ str      ┆ str      ┆ u32     ┆ u32     │
# ╞══════════╪══════════╪═════════╪═════════╡
# │ de       ┆ weiß     ┆ 4       ┆ 5       │
# │ ru       ┆ синий    ┆ 5       ┆ 10      │
# │ es       ┆ amarillo ┆ 8       ┆ 8       │
# └──────────┴──────────┴─────────┴─────────┘

LOWER

Возвращает столбец, преобразованный в нижний регистр.

Пример:

df = pl.DataFrame({"foo": ["AA", "BB", "CC", "DD"]})
df.sql("""
  SELECT foo, LOWER(foo) AS foo_lower FROM self
""")
# shape: (4, 2)
# ┌─────┬───────────┐
# │ foo ┆ foo_lower │
# │ --- ┆ ---       │
# │ str ┆ str       │
# ╞═════╪═══════════╡
# │ AA  ┆ aa        │
# │ BB  ┆ bb        │
# │ CC  ┆ cc        │
# │ DD  ┆ dd        │
# └─────┴───────────┘

LPAD

Дополняет строку слева до заданной длины, используя необязательный символ заполнения (по умолчанию — пробел). Если строка длиннее целевой длины, она усекается.

Пример:

df = pl.DataFrame({"foo": ["hello", "hi", "a", None, "longstr"]})
df.sql("""
  SELECT
    foo,
    LPAD(foo, 7) AS lpad,
    LPAD(foo, 7, 'x') AS lpad_x,
    LPAD(foo, 4, '#') AS lpad_trunc
  FROM self
""")
# shape: (5, 4)
# ┌─────────┬─────────┬─────────┬────────────┐
# │ foo     ┆ lpad    ┆ lpad_x  ┆ lpad_trunc │
# │ ---     ┆ ---     ┆ ---     ┆ ---        │
# │ str     ┆ str     ┆ str     ┆ str        │
# ╞═════════╪═════════╪═════════╪════════════╡
# │ hello   ┆   hello ┆ xxhello ┆ hell       │
# │ hi      ┆      hi ┆ xxxxxhi ┆ ##hi       │
# │ a       ┆       a ┆ xxxxxxa ┆ ###a       │
# │ null    ┆ null    ┆ null    ┆ null       │
# │ longstr ┆ longstr ┆ longstr ┆ long       │
# └─────────┴─────────┴─────────┴────────────┘

LTRIM

Удаляет пробельные символы слева.

Пример:

df = pl.DataFrame({"foo": ["   AA", " BB", "CC", "  DD"]})
df.sql("""
  SELECT foo, LTRIM(foo) AS trimmed FROM self
""")
# shape: (4, 2)
# ┌───────┬─────────┐
# │ foo   ┆ trimmed │
# │ ---   ┆ ---     │
# │ str   ┆ str     │
# ╞═══════╪═════════╡
# │    AA ┆ AA      │
# │  BB   ┆ BB      │
# │ CC    ┆ CC      │
# │   DD  ┆ DD      │
# └───────┴─────────┘

NORMALIZE

Преобразует строку в указанную форму нормализации Unicode (одну из NFC, NFD, NFKC, NFKD). Если форма нормализации не указана, по умолчанию используется NFC.

Пример:

df = pl.DataFrame({
    "txt": [
        "Ｔｅｓｔ",
        "Ⓣⓔⓢⓣ",
        "𝕿𝖊𝖘𝖙",
        "𝕋𝕖𝕤𝕥",
        "𝗧𝗲𝘀𝘁",
    ],
})
df.sql("""
  SELECT NORMALIZE(txt, NFKC) FROM self
""").to_series()
# shape: (5,)
# Series: 'txt' [str]
# [
#   "Test"
#   "Test"
#   "Test"
#   "Test"
#   "Test"
# ]

OCTET_LENGTH

Возвращает длину заданной строки в байтах.

Пример:

df = pl.DataFrame(
  {
    "iso_lang":["de", "ru", "es"],
    "color": ["weiß", "синий", "amarillo"],
  }
)
df.sql("""
  SELECT
    iso_lang,
    color,
    OCTET_LENGTH(color) AS n_bytes,
    LENGTH(color) AS n_chars
  FROM self
""")
# shape: (3, 4)
# ┌──────────┬──────────┬─────────┬─────────┐
# │ iso_lang ┆ color    ┆ n_bytes ┆ n_chars │
# │ ---      ┆ ---      ┆ ---     ┆ ---     │
# │ str      ┆ str      ┆ u32     ┆ u32     │
# ╞══════════╪══════════╪═════════╪═════════╡
# │ de       ┆ weiß     ┆ 5       ┆ 4       │
# │ ru       ┆ синий    ┆ 10      ┆ 5       │
# │ es       ┆ amarillo ┆ 8       ┆ 8       │
# └──────────┴──────────┴─────────┴─────────┘

POSITION

Возвращает позицию подстроки в строке. Индексация начинается с 1; если подстрока не найдена, возвращается 0.

См. также

STRPOS — эквивалентный синтаксис вызова функции.

Пример:

df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
df.sql("""
  SELECT foo, POSITION('an' IN foo) AS pos FROM self
""")
# shape: (4, 2)
# ┌────────┬─────┐
# │ foo    ┆ pos │
# │ ---    ┆ --- │
# │ str    ┆ u32 │
# ╞════════╪═════╡
# │ apple  ┆ 0   │
# │ banana ┆ 2   │
# │ orange ┆ 3   │
# │ grape  ┆ 0   │
# └────────┴─────┘

REGEXP_LIKE

Возвращает True, если pattern соответствует значению (необязательно: flags).

Пример:

df = pl.DataFrame({"foo": ["abc123", "4ab4a", "abc456", "321cba"]})
df.sql(r"""
  SELECT foo, REGEXP_LIKE(foo, '\d$') AS ends_in_digit FROM self
""")
# shape: (4, 2)
# ┌────────┬───────────────┐
# │ foo    ┆ ends_in_digit │
# │ ---    ┆ ---           │
# │ str    ┆ bool          │
# ╞════════╪═══════════════╡
# │ abc123 ┆ true          │
# │ 4ab4a  ┆ false         │
# │ abc456 ┆ true          │
# │ 321cba ┆ false         │
# └────────┴───────────────┘

REPLACE

Заменяет заданную подстроку другой строкой.

Пример:

df = pl.DataFrame({"foo": ["abc123", "11aabb", "bcbc45"]})
df.sql("""
  SELECT foo, REPLACE(foo, 'b', '?') AS bar FROM self
""")
# shape: (3, 2)
# ┌────────┬────────┐
# │ foo    ┆ bar    │
# │ ---    ┆ ---    │
# │ str    ┆ str    │
# ╞════════╪════════╡
# │ abc123 ┆ a?c123 │
# │ 11aabb ┆ 11aa?? │
# │ bcbc45 ┆ ?c?c45 │
# └────────┴────────┘

REVERSE

Возвращает строку в обратном порядке.

Пример:

df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
df.sql("""
  SELECT foo, REVERSE(foo) AS oof FROM self
""")
# shape: (4, 2)
# ┌────────┬────────┐
# │ foo    ┆ oof    │
# │ ---    ┆ ---    │
# │ str    ┆ str    │
# ╞════════╪════════╡
# │ apple  ┆ elppa  │
# │ banana ┆ ananab │
# │ orange ┆ egnaro │
# │ grape  ┆ eparg  │
# └────────┴────────┘

RIGHT

Возвращает последние (самые правые) n символов.

Пример:

df = pl.DataFrame({"foo": ["ab", "cde", "fghi", "jklmn"]})
df.sql("""
  SELECT foo, RIGHT(foo, 2) AS bar FROM self
""")
# shape: (4, 2)
# ┌───────┬─────┐
# │ foo   ┆ bar │
# │ ---   ┆ --- │
# │ str   ┆ str │
# ╞═══════╪═════╡
# │ ab    ┆ ab  │
# │ cde   ┆ de  │
# │ fghi  ┆ hi  │
# │ jklmn ┆ mn  │
# └───────┴─────┘

RPAD

Дополняет строку справа до заданной длины, используя необязательный символ заполнения (по умолчанию — пробел). Если строка длиннее целевой длины, она усекается.

Пример:

df = pl.DataFrame({"foo": ["hello", "hi", "a", None, "longstr"]})
df.sql("""
  SELECT
    foo,
    RPAD(foo, 7) AS rpad,
    RPAD(foo, 7, '-') AS rpad_dash,
    RPAD(foo, 4, '#') AS rpad_trunc
  FROM self
""")
# shape: (5, 4)
# ┌─────────┬─────────┬───────────┬────────────┐
# │ foo     ┆ rpad    ┆ rpad_dash ┆ rpad_trunc │
# │ ---     ┆ ---     ┆ ---       ┆ ---        │
# │ str     ┆ str     ┆ str       ┆ str        │
# ╞═════════╪═════════╪═══════════╪════════════╡
# │ hello   ┆ hello   ┆ hello--   ┆ hell       │
# │ hi      ┆ hi      ┆ hi-----   ┆ hi##       │
# │ a       ┆ a       ┆ a------   ┆ a###       │
# │ null    ┆ null    ┆ null      ┆ null       │
# │ longstr ┆ longstr ┆ longstr   ┆ long       │
# └─────────┴─────────┴───────────┴────────────┘

RTRIM

Удаляет пробельные символы справа.

Пример:

df = pl.DataFrame({"bar": ["zz    ", "yy  ", "xx ", "ww   "]})
df.sql("""
  SELECT bar, RTRIM(bar) AS baz FROM self
""")
# shape: (4, 2)
# ┌────────┬─────┐
# │ bar    ┆ baz │
# │ ---    ┆ --- │
# │ str    ┆ str │
# ╞════════╪═════╡
# │ zz     ┆ zz  │
# │ yy     ┆ yy  │
# │ xx     ┆ xx  │
# │ ww     ┆ ww  │
# └────────┴─────┘

SPLIT_PART

Разбивает строку по другой подстроке/разделителю и возвращает часть с номером n; обратите внимание, что n нумеруется с 1.

Пример:

df = pl.DataFrame({"s": ["xx,yy,zz", "abc,,xyz,???,hmm", None, ""]})
df.sql("""
  SELECT
    s,
    SPLIT_PART(s,',',1) AS "s+1",
    SPLIT_PART(s,',',3) AS "s+3",
    SPLIT_PART(s,',',-2) AS "s-2",
  FROM self
""")
# shape: (4, 4)
# ┌──────────────────┬──────┬──────┬──────┐
# │ s                ┆ s+1  ┆ s+3  ┆ s-2  │
# │ ---              ┆ ---  ┆ ---  ┆ ---  │
# │ str              ┆ str  ┆ str  ┆ str  │
# ╞══════════════════╪══════╪══════╪══════╡
# │ xx,yy,zz         ┆ xx   ┆ zz   ┆ yy   │
# │ abc,,xyz,???,hmm ┆ abc  ┆ xyz  ┆ ???  │
# │ null             ┆ null ┆ null ┆ null │
# │                  ┆      ┆      ┆      │
# └──────────────────┴──────┴──────┴──────┘

STARTS_WITH

Возвращает True, если значение начинается со второго аргумента.

Пример:

df = pl.DataFrame({"foo": ["apple", "banana", "avocado", "grape"]})
df.sql("""
  SELECT foo, STARTS_WITH(foo, 'a') AS starts_a FROM self
""")
# shape: (4, 2)
# ┌─────────┬──────────┐
# │ foo     ┆ starts_a │
# │ ---     ┆ ---      │
# │ str     ┆ bool     │
# ╞═════════╪══════════╡
# │ apple   ┆ true     │
# │ banana  ┆ false    │
# │ avocado ┆ true     │
# │ grape   ┆ false    │
# └─────────┴──────────┘

STRING_TO_ARRAY

Разбивает строку по другой подстроке/разделителю и возвращает массив строк.

Пример:

df = pl.DataFrame({"foo": ["aa,bb,cc", "x,y"]})
df.sql("""
  SELECT foo, STRING_TO_ARRAY(foo, ',') AS arr FROM self
""")
# shape: (2, 2)
# ┌──────────┬────────────────────┐
# │ foo      ┆ arr                │
# │ ---      ┆ ---                │
# │ str      ┆ list[str]          │
# ╞══════════╪════════════════════╡
# │ aa,bb,cc ┆ ["aa", "bb", "cc"] │
# │ x,y      ┆ ["x", "y"]         │
# └──────────┴────────────────────┘

STRPOS

Возвращает индекс заданной подстроки в целевой строке.

Пример:

df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
df.sql("""
  SELECT foo, STRPOS(foo, 'a') AS pos_a FROM self
""")
# shape: (4, 2)
# ┌────────┬───────┐
# │ foo    ┆ pos_a │
# │ ---    ┆ ---   │
# │ str    ┆ u32   │
# ╞════════╪═══════╡
# │ apple  ┆ 1     │
# │ banana ┆ 2     │
# │ orange ┆ 3     │
# │ grape  ┆ 3     │
# └────────┴───────┘

STRPTIME

Преобразует строку в Datetime, используя строку формата, совместимую с chrono strftime.

Пример:

df = pl.DataFrame(
  {
    "s_dt": ["1969 Oct 30", "2024 Jul 05", "2077 Feb 28"],
    "s_tm": ["00.30.55", "12.40.15", "10.45.00"],
  }
)
df.sql("""
  SELECT
    s_dt,
    s_tm,
    STRPTIME(s_dt || ' ' || s_tm, '%Y %b %d %H.%M.%S') AS dtm
  FROM self
""")
# shape: (3, 3)
# ┌─────────────┬──────────┬─────────────────────┐
# │ s_dt        ┆ s_tm     ┆ dtm                 │
# │ ---         ┆ ---      ┆ ---                 │
# │ str         ┆ str      ┆ datetime[μs]        │
# ╞═════════════╪══════════╪═════════════════════╡
# │ 1969 Oct 30 ┆ 00.30.55 ┆ 1969-10-30 00:30:55 │
# │ 2024 Jul 05 ┆ 12.40.15 ┆ 2024-07-05 12:40:15 │
# │ 2077 Feb 28 ┆ 10.45.00 ┆ 2077-02-28 10:45:00 │
# └─────────────┴──────────┴─────────────────────┘

SUBSTR

Возвращает фрагмент строковых данных (начиная с заданного индекса, с необязательной длиной); обратите внимание, что start нумеруется с 1.

См. также

SUBSTRING поддерживает дополнительную форму (FROM ... FOR ...).

Пример:

df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
df.sql("""
  SELECT foo, SUBSTR(foo, 3, 4) AS foo_3_4 FROM self
""")
# shape: (4, 2)
# ┌────────┬─────────┐
# │ foo    ┆ foo_3_4 │
# │ ---    ┆ ---     │
# │ str    ┆ str     │
# ╞════════╪═════════╡
# │ apple  ┆ ple     │
# │ banana ┆ nana    │
# │ orange ┆ ange    │
# │ grape  ┆ ape     │
# └────────┴─────────┘

SUBSTRING

См. также

SUBSTR — более простой синтаксис вызова функции.

Поддерживается несколько форм:

SUBSTRING(str, start)
SUBSTRING(str, start, length)
SUBSTRING(str FROM start)
SUBSTRING(str FROM start FOR length)

Обратите внимание, что start нумеруется с 1.

Пример:

df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
df.sql("""
  SELECT foo, SUBSTRING(foo FROM 2 FOR 3) AS foo_2_3 FROM self
""")
# shape: (4, 2)
# ┌────────┬─────────┐
# │ foo    ┆ foo_2_3 │
# │ ---    ┆ ---     │
# │ str    ┆ str     │
# ╞════════╪═════════╡
# │ apple  ┆ ppl     │
# │ banana ┆ ana     │
# │ orange ┆ ran     │
# │ grape  ┆ rap     │
# └────────┴─────────┘

TIMESTAMP

Преобразует строку с датой в заданном формате в значение типа Datetime; по умолчанию используется формат ISO-8601, если во втором параметре не указана строка формата, совместимая со strftime.

Псевдонимы

DATETIME

Примечание

TIMESTAMP также поддерживается в качестве типизированного литерала (эта форма не позволяет указать строку формата).

SELECT TIMESTAMP '2077-12-10 22:30:45' AS ts

Пример:

df = pl.DataFrame(
  {
    "str_timestamp": [
      "1969 July 30, 00:30:55",
      "2030-October-08, 12:40:15",
      "2077 February 28, 10:45:00",
    ]
  }
)
df.sql("""
  SELECT str_timestamp, TIMESTAMP(str_date, '%Y.%m.%d') AS date FROM self
""")
# shape: (3, 2)
# ┌────────────┬────────────┐
# │ str_date   ┆ date       │
# │ ---        ┆ ---        │
# │ str        ┆ date       │
# ╞════════════╪════════════╡
# │ 1969.10.30 ┆ 1969-10-30 │
# │ 2024.07.05 ┆ 2024-07-05 │
# │ 2077.02.28 ┆ 2077-02-28 │
# └────────────┴────────────┘

TRIM

Удаляет символы слева и/или справа от строки.

Синтаксис:

TRIM(expr) — удаляет пробельные символы с обеих сторон.
TRIM(BOTH char FROM expr) — удаляет char с обеих сторон.
TRIM(LEADING char FROM expr) — удаляет char слева.
TRIM(TRAILING char FROM expr) — удаляет char справа.

Пример:

df = pl.DataFrame({"foo": ["  hello  ", "  world  ", "  test  "]})
df.sql("""
  SELECT
    foo,
    TRIM(foo) AS trimmed,
    TRIM(LEADING ' ' FROM foo) AS ltrimmed,
    TRIM(TRAILING ' ' FROM foo) AS rtrimmed
  FROM self
""")
# shape: (3, 4)
# ┌───────────┬─────────┬──────────┬──────────┐
# │ foo       ┆ trimmed ┆ ltrimmed ┆ rtrimmed │
# │ ---       ┆ ---     ┆ ---      ┆ ---      │
# │ str       ┆ str     ┆ str      ┆ str      │
# ╞═══════════╪═════════╪══════════╪══════════╡
# │   hello   ┆ hello   ┆ hello    ┆   hello  │
# │   world   ┆ world   ┆ world    ┆   world  │
# │   test    ┆ test    ┆ test     ┆   test   │
# └───────────┴─────────┴──────────┴──────────┘

UPPER

Возвращает столбец, преобразованный в верхний регистр.

Пример:

df = pl.DataFrame({"foo": ["apple", "banana", "orange", "grape"]})
df.sql("""
  SELECT foo, UPPER(foo) AS foo_upper FROM self
""")
# shape: (4, 2)
# ┌────────┬───────────┐
# │ foo    ┆ foo_upper │
# │ ---    ┆ ---       │
# │ str    ┆ str       │
# ╞════════╪═══════════╡
# │ apple  ┆ APPLE     │
# │ banana ┆ BANANA    │
# │ orange ┆ ORANGE    │
# │ grape  ┆ GRAPE     │
# └────────┴───────────┘

© 2020 Ritchie Vink
© 2022 Polars contributors
Licensed under the MIT License.
https://docs.pola.rs/api/python/stable/reference/sql/functions/string.html