feat(psql): introduce column type `ltree` #604

EstebanBorai · 2023-02-15T03:47:46Z

PR Info

Introduces the ltree type for PostgreSQL.

Closes

New Features

PostgreSQL ltree support

EstebanBorai · 2023-02-15T03:51:58Z

Thanks for this amazing library! I wanted to help introducing ltree to the library and decided to go ahead and implement support for PostgreSQL. Theres still some bits that require some decisions.

How can we have the CREATE EXTENSION ltree statement to be executed when using this type?
Is it possible to have certain operators on this type? Turns out ltree comes with poweful operators as well: https://www.postgresql.org/docs/current/ltree.html#LTREE-OP-TABLE
It would be great to have this type available for sea-orm as well, my goal is to have this type being supported in the orm as well.

Thanks in advance!

billy1624

Hey @EstebanBorai, sorry for the delay and thanks for contributing!!

src/extension/postgres/ltree.rs

billy1624 · 2023-02-24T14:25:14Z

How can we have the CREATE EXTENSION ltree statement to be executed when using this type?

I'd suggest adding a ExtensionCreateStatement similar to the TypeCreateStatement that we already had https://docs.rs/sea-query/latest/sea_query/extension/postgres/struct.TypeCreateStatement.html

Is it possible to have certain operators on this type? Turns out ltree comes with poweful operators as well: https://www.postgresql.org/docs/current/ltree.html#LTREE-OP-TABLE

Sure! Postgres specific operators goes to PgBinOper:

sea-query/src/extension/postgres/mod.rs

Lines 13 to 28 in fd27b12

    
           /// Binary operator 
        
           #[derive(Debug, Clone, Copy, PartialEq, Eq)] 
        
           pub enum PgBinOper { 
        
               ILike, 
        
               NotILike, 
        
               Matches, 
        
               Contains, 
        
               Contained, 
        
               Concatenate, 
        
               Similarity, 
        
               WordSimilarity, 
        
               StrictWordSimilarity, 
        
               SimilarityDistance, 
        
               WordSimilarityDistance, 
        
               StrictWordSimilarityDistance, 
        
           }

And its construct goes to PgExpr:

sea-query/src/extension/postgres/expr.rs

Lines 1 to 151 in fd27b12

    
           use super::PgBinOper; 
        
           use crate::{expr::private::Expression, Expr, IntoLikeExpr, SimpleExpr}; 
        
           pub trait PgExpr: Expression { 
        
               /// Express an postgres concatenate (`||`) expression. 
        
               /// 
        
               /// # Examples 
        
               /// 
        
               /// ``` 
        
               /// use sea_query::{extension::postgres::PgExpr, tests_cfg::*, *}; 
        
               /// 
        
               /// let query = Query::select() 
        
               ///     .columns([Font::Name, Font::Variant, Font::Language]) 
        
               ///     .from(Font::Table) 
        
               ///     .and_where(Expr::val("a").concatenate("b").concat("c").concat("d")) 
        
               ///     .to_owned(); 
        
               /// 
        
               /// assert_eq!( 
        
               ///     query.to_string(PostgresQueryBuilder), 
        
               ///     r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a' || 'b' || 'c' || 'd'"# 
        
               /// ); 
        
               /// ``` 
        
               fn concatenate<T>(self, right: T) -> SimpleExpr 
        
               where 
        
                   T: Into<SimpleExpr>, 
        
               { 
        
                   self.bin_op(PgBinOper::Concatenate, right) 
        
               } 
        
               /// Alias of [`PgExpr::concatenate`] 
        
               fn concat<T>(self, right: T) -> SimpleExpr 
        
               where 
        
                   T: Into<SimpleExpr>, 
        
               { 
        
                   self.concatenate(right) 
        
               } 
        
               /// Express an postgres fulltext search matches (`@@`) expression. 
        
               /// 
        
               /// # Examples 
        
               /// 
        
               /// ``` 
        
               /// use sea_query::{*, tests_cfg::*, extension::postgres::PgExpr}; 
        
               /// 
        
               /// let query = Query::select() 
        
               ///     .columns([Font::Name, Font::Variant, Font::Language]) 
        
               ///     .from(Font::Table) 
        
               ///     .and_where(Expr::val("a & b").matches("a b")) 
        
               ///     .and_where(Expr::col(Font::Name).matches("a b")) 
        
               ///     .to_owned(); 
        
               /// 
        
               /// assert_eq!( 
        
               ///     query.to_string(PostgresQueryBuilder), 
        
               ///     r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a & b' @@ 'a b' AND "name" @@ 'a b'"# 
        
               /// ); 
        
               /// ``` 
        
               fn matches<T>(self, expr: T) -> SimpleExpr 
        
               where 
        
                   T: Into<SimpleExpr>, 
        
               { 
        
                   self.bin_op(PgBinOper::Matches, expr) 
        
               } 
        
               /// Express an postgres fulltext search contains (`@>`) expression. 
        
               /// 
        
               /// # Examples 
        
               /// 
        
               /// ``` 
        
               /// use sea_query::{*, tests_cfg::*, extension::postgres::PgExpr}; 
        
               /// 
        
               /// let query = Query::select() 
        
               ///     .columns([Font::Name, Font::Variant, Font::Language]) 
        
               ///     .from(Font::Table) 
        
               ///     .and_where(Expr::val("a & b").contains("a b")) 
        
               ///     .and_where(Expr::col(Font::Name).contains("a b")) 
        
               ///     .to_owned(); 
        
               /// 
        
               /// assert_eq!( 
        
               ///     query.to_string(PostgresQueryBuilder), 
        
               ///     r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a & b' @> 'a b' AND "name" @> 'a b'"# 
        
               /// ); 
        
               /// ``` 
        
               fn contains<T>(self, expr: T) -> SimpleExpr 
        
               where 
        
                   T: Into<SimpleExpr>, 
        
               { 
        
                   self.bin_op(PgBinOper::Contains, expr) 
        
               } 
        
               /// Express an postgres fulltext search contained (`<@`) expression. 
        
               /// 
        
               /// # Examples 
        
               /// 
        
               /// ``` 
        
               /// use sea_query::{*, tests_cfg::*, extension::postgres::PgExpr}; 
        
               /// 
        
               /// let query = Query::select() 
        
               ///     .columns([Font::Name, Font::Variant, Font::Language]) 
        
               ///     .from(Font::Table) 
        
               ///     .and_where(Expr::val("a & b").contained("a b")) 
        
               ///     .and_where(Expr::col(Font::Name).contained("a b")) 
        
               ///     .to_owned(); 
        
               /// 
        
               /// assert_eq!( 
        
               ///     query.to_string(PostgresQueryBuilder), 
        
               ///     r#"SELECT "name", "variant", "language" FROM "font" WHERE 'a & b' <@ 'a b' AND "name" <@ 'a b'"# 
        
               /// ); 
        
               /// ``` 
        
               fn contained<T>(self, expr: T) -> SimpleExpr 
        
               where 
        
                   T: Into<SimpleExpr>, 
        
               { 
        
                   self.bin_op(PgBinOper::Contained, expr) 
        
               } 
        
               /// Express a `ILIKE` expression. 
        
               /// 
        
               /// # Examples 
        
               /// 
        
               /// ``` 
        
               /// use sea_query::{*, tests_cfg::*, extension::postgres::PgExpr}; 
        
               /// 
        
               /// let query = Query::select() 
        
               ///     .columns([Char::Character, Char::SizeW, Char::SizeH]) 
        
               ///     .from(Char::Table) 
        
               ///     .and_where(Expr::col((Char::Table, Char::Character)).ilike("Ours'%")) 
        
               ///     .to_owned(); 
        
               /// 
        
               /// assert_eq!( 
        
               ///     query.to_string(PostgresQueryBuilder), 
        
               ///     r#"SELECT "character", "size_w", "size_h" FROM "character" WHERE "character"."character" ILIKE E'Ours\'%'"# 
        
               /// ); 
        
               /// ``` 
        
               fn ilike<L>(self, like: L) -> SimpleExpr 
        
               where 
        
                   L: IntoLikeExpr, 
        
               { 
        
                   self.like_like(PgBinOper::ILike, like.into_like_expr()) 
        
               } 
        
               /// Express a `NOT ILIKE` expression 
        
               fn not_ilike<L>(self, like: L) -> SimpleExpr 
        
               where 
        
                   L: IntoLikeExpr, 
        
               { 
        
                   self.like_like(PgBinOper::NotILike, like.into_like_expr()) 
        
               } 
        
           } 
        
           impl PgExpr for Expr {} 
        
           impl PgExpr for SimpleExpr {}

It would be great to have this type available for sea-orm as well, my goal is to have this type being supported in the orm as well.

That would be nice! But one step at a time, we should focus on bring it onto SeaQuery first.

EstebanBorai · 2023-02-27T14:01:12Z

I'd suggest adding a ExtensionCreateStatement similar to the TypeCreateStatement that we already had https://docs.rs/sea-query/latest/sea_query/extension/postgres/struct.TypeCreateStatement.html

Just to be clear, the user will be responsible of running this code as part of writing migrations when using the PgLTree type, right?

billy1624 · 2023-03-07T02:31:20Z

I'd suggest adding a ExtensionCreateStatement similar to the TypeCreateStatement that we already had https://docs.rs/sea-query/latest/sea_query/extension/postgres/struct.TypeCreateStatement.html

Just to be clear, the user will be responsible of running this code as part of writing migrations when using the PgLTree type, right?

You're right!

billy1624 · 2023-03-07T02:46:03Z

Hey @EstebanBorai, would you like to introduce the follow things as discussed above?

Adding ExtensionCreateStatement
Adding LTree related operators to PgBinOper
Adding constructs for LTree related opertros to PgExpr

EstebanBorai · 2023-03-07T04:39:30Z

Hey @EstebanBorai, would you like to introduce the follow things as discussed above?

Adding ExtensionCreateStatement

Adding LTree related operators to PgBinOper

Adding constructs for LTree related opertros to PgExpr

Hi @billy1624!

Here is a PR for the "Adding ExtensionCreateStatement" task!

tyt2y3

Since this is a Postgres only feature, we have to put it under extensions. Please refer to the pg Type statement.

ikrivosheev · 2023-03-19T18:21:16Z

@EstebanBorai hello! Any updates?

EstebanBorai · 2023-03-19T19:26:42Z

@EstebanBorai hello! Any updates?

Hi @ikrivosheev actually this PR is waiting for this other: #616 where Create Extension Statement is being introduced for PSQL!

After that is merged I will be able to continue working on this!

EstebanBorai · 2023-07-15T22:14:54Z

Hi @billy1624 and @ikrivosheev !

Given that we landed #616 Im planning to move forward and introduce the ltree extension.
Do you guys have any preferences or suggestions on how to accomplish this?

src/table/column.rs

EstebanBorai · 2023-09-12T02:28:22Z

Hi @billy1624 and @ikrivosheev!

Im working on the LTree type now, the missing work to have this implementation ready is providing support to the LTree specialized operations and functions.

LTree supports widely used comparison operators such as <, >, >=, <=, <> =.
But theres also functions and other operators which are available for this column type only.

Is there a place where we could introduce them? I saw sea-query-postgres has specialized types for PostgreSQL Column types, like MacAddress, UUID and Date/Time. Perhaps thats a place for this purpose?

With regards to operators, it would be awesome to have access to them on WHERE clauses, to be able to use on use cases like:

ltreetest=> SELECT path FROM test WHERE path <@ 'Top.Science';
                path
------------------------------------
 Top.Science
 Top.Science.Astronomy
 Top.Science.Astronomy.Astrophysics
 Top.Science.Astronomy.Cosmology
(4 rows)

Then for functions I think its a bit more complex, we should be able to create queries like:

ltreetest=> SELECT subpath(path,0,2)||'Space'||subpath(path,2) FROM test WHERE path <@ 'Top.Science.Astronomy';
                 ?column?
------------------------------------------
 Top.Science.Space.Astronomy
 Top.Science.Space.Astronomy.Astrophysics
 Top.Science.Space.Astronomy.Cosmology
(3 rows)

Perhaps theres a way to partially introduce LTree support? Perhaps we could have operators support on a release and then have functions support?

Thanks in advance!

EstebanBorai · 2023-09-12T02:29:52Z

@ikrivosheev I just introduced the PgLTree here type in case we want to use it for Query specialized operators.

EstebanBorai · 2023-09-24T03:31:27Z

Hi guys! @billy1624 @ikrivosheev any updates on this? It would be awesome to merge this and move into SeoORM 🚀

tyt2y3

Nice and cleanly done. I'd probably add a doc test

github-actions · 2023-11-22T22:16:46Z

🎉 Released In 0.30.3 🎉

Thank you everyone for the contribution!
This feature is now available in the latest release. Now is a good time to upgrade!
Your participation is what makes us unique; your adoption is what drives us forward.
You can support SeaQL 🌊 by starring our repos, sharing our libraries and becoming a sponsor ⭐.

billy1624 assigned EstebanBorai Feb 24, 2023

billy1624 reviewed Feb 24, 2023

View reviewed changes

src/extension/postgres/ltree.rs Outdated Show resolved Hide resolved

EstebanBorai requested a review from billy1624 February 28, 2023 15:15

EstebanBorai mentioned this pull request Mar 7, 2023

feat: extension create statement for PostgreSQL #616

Merged

1 task

tyt2y3 requested changes Mar 8, 2023

View reviewed changes

EstebanBorai force-pushed the feat/postgresql-ltree branch from 33436e4 to 3094255 Compare July 15, 2023 22:12

EstebanBorai changed the title ~~feat: introduce column type ltree~~ feat(psql): introduce column type ltree Jul 15, 2023

ikrivosheev reviewed Jul 27, 2023

View reviewed changes

src/table/column.rs Outdated Show resolved Hide resolved

EstebanBorai force-pushed the feat/postgresql-ltree branch from af4ab9f to bc5e40e Compare September 9, 2023 18:03

feat: introduce LTree column type

3569d54

EstebanBorai force-pushed the feat/postgresql-ltree branch from bc5e40e to 3569d54 Compare September 9, 2023 18:07

feat: the ltree type

e7ac0fa

EstebanBorai requested review from tyt2y3 and ikrivosheev September 12, 2023 02:28

tyt2y3 approved these changes Oct 4, 2023

View reviewed changes

tyt2y3 merged commit cc8e78c into SeaQL:master Oct 4, 2023
20 checks passed

EstebanBorai deleted the feat/postgresql-ltree branch October 5, 2023 18:32

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

feat(psql): introduce column type `ltree` #604

feat(psql): introduce column type `ltree` #604

EstebanBorai commented Feb 15, 2023 •

edited

Loading

EstebanBorai commented Feb 15, 2023

billy1624 left a comment

billy1624 commented Feb 24, 2023 •

edited

Loading

EstebanBorai commented Feb 27, 2023

billy1624 commented Mar 7, 2023

billy1624 commented Mar 7, 2023

EstebanBorai commented Mar 7, 2023

tyt2y3 left a comment

ikrivosheev commented Mar 19, 2023

EstebanBorai commented Mar 19, 2023

EstebanBorai commented Jul 15, 2023

EstebanBorai commented Sep 12, 2023

EstebanBorai commented Sep 12, 2023

EstebanBorai commented Sep 24, 2023

tyt2y3 left a comment

github-actions bot commented Nov 22, 2023

feat(psql): introduce column type ltree #604

feat(psql): introduce column type ltree #604

Conversation

EstebanBorai commented Feb 15, 2023 • edited Loading

PR Info

New Features

EstebanBorai commented Feb 15, 2023

billy1624 left a comment

Choose a reason for hiding this comment

billy1624 commented Feb 24, 2023 • edited Loading

EstebanBorai commented Feb 27, 2023

billy1624 commented Mar 7, 2023

billy1624 commented Mar 7, 2023

EstebanBorai commented Mar 7, 2023

tyt2y3 left a comment

Choose a reason for hiding this comment

ikrivosheev commented Mar 19, 2023

EstebanBorai commented Mar 19, 2023

EstebanBorai commented Jul 15, 2023

EstebanBorai commented Sep 12, 2023

EstebanBorai commented Sep 12, 2023

EstebanBorai commented Sep 24, 2023

tyt2y3 left a comment

Choose a reason for hiding this comment

github-actions bot commented Nov 22, 2023

🎉 Released In 0.30.3 🎉

feat(psql): introduce column type `ltree` #604

feat(psql): introduce column type `ltree` #604

EstebanBorai commented Feb 15, 2023 •

edited

Loading

billy1624 commented Feb 24, 2023 •

edited

Loading