sea orm

Orage maritime

? Un orm async et dynamique pour la rouille

Orage maritime

Seaorm est un ORM relationnel pour vous aider à créer des services Web en rouille avec la familiarité des langues dynamiques.

Si vous aimez ce que nous faisons, envisagez de jouer, de partager et de contribuer!

Veuillez nous aider à maintenir Seaorm en remplissant le SeaQL Community Survey 2024!

Rejoignez notre serveur Discord pour discuter avec d'autres membres de la communauté SeaQL!

Commencer

• Documentation
• Tutoriel
• Livre de cuisine

Exemples d'intégration:

• Exemple Actix V4
• Exemple de l'axe
• Exemple GraphQL
• Exemple JSONRPSEE
• Loco Too Exemple / Loco Rest Starter
• Exemple de poème
• Exemple de fusée / Rocket OpenAPI Exemple
• Exemple de salve
• Exemple tonique
• Exemple de Seographier

Caractéristiques

1. Asynchrone

   S'appuyant sur SQLX, Seaorm est une nouvelle bibliothèque avec un support asynchrone du jour 1.

2. Dynamique

   Construit sur Seaquey, Seaorm vous permet de construire des requêtes dynamiques complexes.

3. Testable

   Utilisez des connexions simulées et / ou SQLite pour rédiger des tests pour votre logique d'application.

4. Orienté vers le service

   Créez rapidement des services qui rejoignent, filtrent, trie et paginent les données dans les API REST, GraphQL et GRPC.

Un goût rapide de Seaorm

Entité

 use sea_orm :: entity :: prelude :: * ;

# [ derive ( Clone , Debug , PartialEq , DeriveEntityModel ) ]
# [ sea_orm ( table_name = "cake" ) ]
pub struct Model {
    # [ sea_orm ( primary_key ) ]
    pub id : i32 ,
    pub name : String ,
}

# [ derive ( Copy , Clone , Debug , EnumIter , DeriveRelation ) ]
pub enum Relation {
    # [ sea_orm ( has_many = "super::fruit::Entity" ) ]
    Fruit ,
}

impl Related < super :: fruit :: Entity > for Entity {
    fn to ( ) -> RelationDef {
        Relation :: Fruit . def ( )
    }
}

Sélectionner

 // find all models
let cakes : Vec < cake :: Model > = Cake :: find ( ) . all ( db ) . await ? ;

// find and filter
let chocolate : Vec < cake :: Model > = Cake :: find ( )
    . filter ( cake :: Column :: Name . contains ( "chocolate" ) )
    . all ( db )
    . await ? ;

// find one model
let cheese : Option < cake :: Model > = Cake :: find_by_id ( 1 ) . one ( db ) . await ? ;
let cheese : cake :: Model = cheese . unwrap ( ) ;

// find related models (lazy)
let fruits : Vec < fruit :: Model > = cheese . find_related ( Fruit ) . all ( db ) . await ? ;

// find related models (eager)
let cake_with_fruits : Vec < ( cake :: Model , Vec < fruit :: Model > ) > =
    Cake :: find ( ) . find_with_related ( Fruit ) . all ( db ) . await ? ;

Insérer

 let apple = fruit :: ActiveModel {
    name : Set ( "Apple" . to_owned ( ) ) ,
    .. Default :: default ( ) // no need to set primary key
} ;

let pear = fruit :: ActiveModel {
    name : Set ( "Pear" . to_owned ( ) ) ,
    .. Default :: default ( )
} ;

// insert one
let pear = pear . insert ( db ) . await ? ;

// insert many
Fruit :: insert_many ( [ apple , pear ] ) . exec ( db ) . await ? ;

Mise à jour

 use sea_orm :: sea_query :: { Expr , Value } ;

let pear : Option < fruit :: Model > = Fruit :: find_by_id ( 1 ) . one ( db ) . await ? ;
let mut pear : fruit :: ActiveModel = pear . unwrap ( ) . into ( ) ;

pear . name = Set ( "Sweet pear" . to_owned ( ) ) ;

// update one
let pear : fruit :: Model = pear . update ( db ) . await ? ;

// update many: UPDATE "fruit" SET "cake_id" = NULL WHERE "fruit"."name" LIKE '%Apple%'
Fruit :: update_many ( )
    . col_expr ( fruit :: Column :: CakeId , Expr :: value ( Value :: Int ( None ) ) )
    . filter ( fruit :: Column :: Name . contains ( "Apple" ) )
    . exec ( db )
    . await ? ;

Sauvegarder

 let banana = fruit :: ActiveModel {
    id : NotSet ,
    name : Set ( "Banana" . to_owned ( ) ) ,
    .. Default :: default ( )
} ;

// create, because primary key `id` is `NotSet`
let mut banana = banana . save ( db ) . await ? ;

banana . name = Set ( "Banana Mongo" . to_owned ( ) ) ;

// update, because primary key `id` is `Set`
let banana = banana . save ( db ) . await ? ;

Supprimer

 // delete one
let orange : Option < fruit :: Model > = Fruit :: find_by_id ( 1 ) . one ( db ) . await ? ;
let orange : fruit :: Model = orange . unwrap ( ) ;
fruit :: Entity :: delete ( orange . into_active_model ( ) )
    . exec ( db )
    . await ? ;

// or simply
let orange : Option < fruit :: Model > = Fruit :: find_by_id ( 1 ) . one ( db ) . await ? ;
let orange : fruit :: Model = orange . unwrap ( ) ;
orange . delete ( db ) . await ? ;

// delete many: DELETE FROM "fruit" WHERE "fruit"."name" LIKE 'Orange'
fruit :: Entity :: delete_many ( )
    . filter ( fruit :: Column :: Name . contains ( "Orange" ) )
    . exec ( db )
    . await ? ; 

? Seography: API GraphQL instantanée

Seographic est un cadre GraphQL construit au sommet de Seaorm. Seographic vous permet de construire rapidement GraphQL Resolvers. Avec seulement quelques commandes, vous pouvez lancer un serveur GraphQL à partir des entités Seaorm!

Regardez l'exemple Seography pour en savoir plus.

Tableau de bord administratif

Utilisant la mer de Seography, ce sera un jeu d'enfant de créer un tableau de bord d'administration avec votre cadre frontal préféré. Consultez nos exemples et tutoriels:

1. Exemple d'administration React
2. Ajout de la prise en charge de GraphQL à Loco avec Seographic
3. Tableau de bord d'administration basé sur GraphQL avec Loco et Seography

Apprendre encore plus

1. Conception
2. Architecture
3. Ingénierie
4. Modifier le journal

Qui utilise Seaorm?

Voir construit avec Seaorm. N'hésitez pas à soumettre le vôtre!

Licence

Sous licence sous l'un ou l'autre des

• Licence Apache, version 2.0 (Licence-apache ou http://www.apache.org/licenses/license-2.0)
• Licence MIT (Licence-mit ou http://openseource.org/licenses/mit)

à votre option.

Contribution

À moins que vous ne soyez explicitement indiqué autrement, toute contribution intentionnellement soumise pour inclusion dans les travaux par vous, telle que définie dans la licence Apache-2.0, doit être autorisée à double licence comme ci-dessus, sans aucune condition supplémentaire.

Nous vous invitons à participer, à contribuer et à aider ensemble à construire l'avenir de Rust.

Un grand cri à nos contributeurs!

Parrainage

Seaql.org est une organisation open source indépendante dirigée par des développeurs passionnés. Si vous aimez utiliser nos bibliothèques, veuillez jouer et partager nos référentiels. Si vous vous sentez généreux, un petit don via le sponsor GitHub sera grandement apprécié et contribue grandement à soutenir l'organisation.

Sponsors d'or

Sponsors d'argent

Nous sommes extrêmement reconnaissants à nos sponsors: OSMOS, pour leur parrainage de niveau d'or et leur confiance dans les outils que nous développons. Digital Ocean, pour parrainer nos serveurs. Et JetBrains, pour parrainer notre IDE.

Mascotte

Un ami de Ferris, terres le crabe ermite est la mascotte officielle de Seaorm. Son passe-temps est de collecter des obus.