queryBuilder= queryBuilder.insert(modelsOrObjects);

const jennifer=await Person.query().insert({firstName:'Jennifer',lastName:'Lawrence'});console.log(jennifer.id);

const actors=await Movie.relatedQuery('actors').for(someMovie).insert([{firstName:'Jennifer',lastName:'Lawrence'},{firstName:'Bradley',lastName:'Cooper'}]);console.log(actors[0].firstName);console.log(actors[1].firstName);

const{ raw}=require('objection');await Person.query().insert({age: Person.query().avg('age'),firstName:raw("'Jenni' || 'fer'")});

const jennifer=await Movie.relatedQuery('actors').for(someMovie).insert({firstName:'Jennifer',lastName:'Lawrence',someExtra:"I'll be written to the join table"});console.log(jennifer.someExtra);

queryBuilder= queryBuilder.insertAndFetch(modelsOrObjects);

queryBuilder= queryBuilder.insertGraph(graph, options);

queryBuilder= queryBuilder.patch(modelOrObject);

TIP

This generates an SQLupdate query. While there's also theupdate method,patch is what you want to use most of the time for updates. Read both methods' documentation carefully. If unsure or hate reading, usepatch to update stuff 😄

WARNING

raw,lit, subqueries and other "query properties" in the patch object are not validated. Also fields specified usingFieldExpressions are not validated.

const numberOfAffectedRows=await Person.query().patch({age:24}).findById(personId);console.log(numberOfAffectedRows);

const numberOfAffectedRows=await Person.query().patch({age:20}).where('age','<',50);

const numberOfAffectedRows=await Person.query().patch({age:raw('age + 1')}).where('age','<',50);

const{ ref, raw}=require('objection');await Person.query().patch({age: Person.query().avg('age'),// You can use knex.raw instead of `raw()` if// you prefer.firstName:raw("'Jenni' || 'fer'"),oldLastName:ref('lastName'),// This updates a value nested deep inside a// json column `detailsJsonColumn`.'detailsJsonColumn:address.street':'Elm street'});

queryBuilder= queryBuilder.patchAndFetchById(id, modelOrObject);

const updatedPerson=await Person.query().patchAndFetchById(134,{age:24});console.log(updatedPerson.firstName);

queryBuilder= queryBuilder.patchAndFetch(modelOrObject);

const jennifer=await Person.query().findOne({firstName:'Jennifer'});const updatedJennifer=await jennifer.$query().patchAndFetch({age:24});console.log(updatedJennifer.firstName);

queryBuilder= queryBuilder.update(modelOrObject);

const numberOfAffectedRows=await Person.query().update({firstName:'Jennifer',lastName:'Lawrence',age:24}).where('id',134);console.log(numberOfAffectedRows);

const{ raw, ref}=require('objection');await Person.query().update({firstName:raw("'Jenni' || 'fer'"),lastName:'Lawrence',age: Person.query().avg('age'),oldLastName:ref('lastName')// same as knex.raw('??', ['lastName'])});

await Person.query().update({lastName:ref('someJsonColumn:mother.lastName').castText(),'detailsJsonColumn:address.street':'Elm street'});

queryBuilder= queryBuilder.updateAndFetchById(id, modelOrObject);

const updatedPerson=await Person.query().updateAndFetchById(134, person);console.log(updatedPerson.firstName);

queryBuilder= queryBuilder.updateAndFetch(modelOrObject);

const jennifer=await Person.query().findOne({firstName:'Jennifer'});const updatedJennifer=await jennifer.$query().updateAndFetch({age:24});console.log(updatedJennifer.firstName);

queryBuilder= queryBuilder.upsertGraph(graph, options);

WARNING

WARNING!

Before you start usingupsertGraph beware that it's not the silver bullet it seems to be. If you start using it because it seems to provide a "mongodb API" for a relational database, you are using it for a wrong reason!

Our suggestion is to first try to write any code without it and only useupsertGraph if it saves youa lot of code and makes things simpler. Over time you'll learn whereupsertGraph helps and where it makes things more complicated. Don't use it by default for everything. You can search through the objection issues to see what kind of problemsupsertGraph can cause if used too much.

For simple thingsupsertGraph calls are easy to understand and remain readable. When you start passing it a bunch of options it becomes increasingly difficult for other developers (and even yourself) to understand.

It's also really easy to create a server that doesn't work well with multiple users by overusingupsertGraph. That's because you can easily get into a situation where you override other user's changes if you always upsert large graphs at a time. Always try to update the minimum amount of rows and columns and you'll save yourself a lot of trouble in the long run.

queryBuilder= queryBuilder.delete();

const numberOfDeletedRows=await Person.query().delete().where('age','>',100);console.log('removed', numberOfDeletedRows,'people');

// This query deletes all people that have a pet named "Fluffy".await Person.query().delete().whereIn('id',    Person.query().select('persons.id').joinRelated('pets').where('pets.name','Fluffy'));// This is another way to implement the same query.await Person.query().delete().whereExists(Person.relatedQuery('pets').where('pets.name','Fluffy'));

const person=await Person.query().findById(personId);// Delete all pets but cats and dogs of a person.await person.$relatedQuery('pets').delete().whereNotIn('species',['cat','dog']);// Delete all pets of a person.await person.$relatedQuery('pets').delete();

queryBuilder= queryBuilder.deleteById(id);

const numberOfDeletedRows=await Person.query().deleteById(1);console.log('removed', numberOfDeletedRows,'people');

const numberOfDeletedRows=await Person.query().deleteById([10,'20',46]);console.log('removed', numberOfDeletedRows,'people');

queryBuilder= queryBuilder.relate(ids);

const actor=await Person.query().findById(100);

select"persons".*from"persons"where"persons"."id"=100

const movie=await Movie.query().findById(200);

select"movies".*from"movies"where"movies"."id"=200

await actor.$relatedQuery('movies').relate(movie);

insertinto"persons_movies"("personId","movieId")values(100,200)

await Person.relatedQuery('movies').for(100).relate(200);

insertinto"persons_movies"("personId","movieId")values(100,200)

await Person.relatedQuery('movies').for(    Person.query().where('firstName','Arnold').limit(1)).relate([100,200,300,400]);

const numRelatedRows=await person.relatedQuery('movies').for(123).relate(50);console.log('movie 50 is now related to person 123 through `movies` relation');

const numRelatedRows=await Person.relatedQuery('movies').for(123).relate([50,60,70]);console.log(`${numRelatedRows} rows were related`);

const numRelatedRows=await Person.relatedQuery('movies').for(123).relate({foo:50,bar:20,baz:10});console.log(`${numRelatedRows} rows were related`);

const numRelatedRows=await Movie.relatedQuery('actors').for(movieId).relate({id:50,someExtra:"I'll be written to the join table"});console.log(`${numRelatedRows} rows were related`);

queryBuilder= queryBuilder.unrelate();

const actor=await Person.query().findById(100);

select"persons".*from"persons"where"persons"."id"=100

await actor.$relatedQuery('movies').unrelate().where('name','like','Terminator%');

deletefrom"persons_movies"where"persons_movies"."personId"=100where"persons_movies"."movieId"in(select"movies"."id"from"movies"where"name"like'Terminator%')

await Person.relatedQuery('movies').for(100).unrelate().where('name','like','Terminator%');

deletefrom"persons_movies"where"persons_movies"."personId"=100and"persons_movies"."movieId"in(select"movies"."id"from"movies"where"name"like'Terminator%')

// Note that we don't await this query. This query is not executed.// It's a placeholder that will be used to build a subquery when// the `relatedQuery` gets executed.const arnold= Person.query().findOne({firstName:'Arnold',lastName:'Schwarzenegger'});await Person.relatedQuery('movies').for(arnold).unrelate().where('name','like','Terminator%');

deletefrom"persons_movies"where"persons_movies"."personId"in(select"persons"."id"from"persons"where"firstName"='Arnold'and"lastName"='Schwarzenegger')and"persons_movies"."movieId"in(select"movies"."id"from"movies"where"name"like'Terminator%')

const person=await Person.query().findById(123);const numUnrelatedRows=await person.$relatedQuery('movies').unrelate().where('id',50);console.log('movie 50 is no longer related to person 123 through `movies` relation');