You signed in with another tab or window.Reload to refresh your session.You signed out in another tab or window.Reload to refresh your session.You switched accounts on another tab or window.Reload to refresh your session.Dismiss alert
If you have questions about how to use Sequel, please ask on GitHub Discussions. Only use the the bug tracker to report bugs in Sequel, not to ask for help on using Sequel.
require'sequel'DB =Sequel.sqlite# memory database, requires sqlite3DB.create_table:itemsdoprimary_key:idString:nameFloat:priceenditems =DB[:items]# Create a dataset# Populate the tableitems.insert(name:'abc',price:rand*100)items.insert(name:'def',price:rand*100)items.insert(name:'ghi',price:rand*100)# Print out the number of recordsputs"Item count: #{items.count}"# Print out the average priceputs"The average price is: #{items.avg(:price)}"
Sequel includes an IRB console for quick access to databases (usually referred to asbin/sequel). You can use it like this:
sequel sqlite://test.db # test.db in current directory
You get an IRB session with the Sequel::Database object stored in DB.
In addition to providing an IRB shell (the default behavior), bin/sequel also has support for migrating databases, dumping schema migrations, and copying databases. See the bin/sequel guide for more details.
Sequel is designed to take the hassle away from connecting to databases and manipulating them. Sequel deals with all the boring stuff like maintaining connections, formatting SQL correctly and fetching records so you can concentrate on your application.
Sequel uses the concept of datasets to retrieve data. A Dataset object encapsulates an SQL query and supports chainability, letting you fetch data using a convenient Ruby DSL that is both concise and flexible.
For example, the following one-liner returns the average GDP for countries in the middle east region:
SELECT avg(GDP) FROM countries WHERE region = 'Middle East'
Since datasets retrieve records only when needed, they can be stored and later reused. Records are fetched as hashes, and are accessed using anEnumerable interface:
The connection URL can also include such stuff as the user name, password, and port:
DB =Sequel.connect('postgres://user:password@host:port/database_name')# requires pg
You can also specify optional parameters, such as the connection pool size, or loggers for logging SQL queries:
DB =Sequel.connect("postgres://user:password@host:port/database_name",max_connections:10,logger:Logger.new('log/db.log'))
It is also possible to use a hash instead of a connection URL, but make sure to include the :adapter option in this case:
DB =Sequel.connect(adapter::postgres,user:'user',password:'password',host:'host',port:port,database:'database_name',max_connections:10,logger:Logger.new('log/db.log'))
You can specify a block to connect, which will disconnect from the database after it completes:
Throughout Sequel’s documentation, you will see theDB constant used to refer to the Sequel::Database instance you create. This reflects the recommendation that for an app with a single Sequel::Database instance, the Sequel convention is to store the instance in theDB constant. This is just a convention, it’s not required, but it is recommended.
Note that some frameworks that use Sequel may create the Sequel::Database instance for you, and you might not know how to access it. In most cases, you can access the Sequel::Database instance throughSequel::Model.db.
You can execute arbitrary SQL code usingDatabase#run:
DB.run("create table t (a text, b text)")DB.run("insert into t values ('a', 'b')")
You can also create datasets based on raw SQL:
dataset =DB['select id from items']dataset.count# will return the number of records in the result setdataset.map(:id)# will return an array containing all values of the id column in the result set
You can also fetch records with raw SQL through the dataset:
DB['select * from items'].eachdo|row|prowend
You can use placeholders in your SQL string as well:
name ='Jim'DB['select * from items where name = ?',name].eachdo|row|prowend
Datasets are the primary way records are retrieved and manipulated. They are generally created via theDatabase#from orDatabase#[] methods:
posts =DB.from(:posts)posts =DB[:posts]# same
Datasets will only fetch records when you tell them to. They can be manipulated to filter records, change ordering, join tables, etc. Datasets are always frozen, and they are safe to use by multiple threads concurrently.
Designing apps with security in mind is a best practice. Please read the Security Guide for details on security issues that you should be aware of when using Sequel.
Note the use ofSequel.desc(:stamp) in the above example. Much of Sequel’s DSL uses this style, calling methods on the Sequel module that return SQL expression objects. Sequel also ships with a core_extensions extension that integrates Sequel’s DSL better into the Ruby language, allowing you to write:
posts.where(Sequel[:stamp]<Date.today-7).update(state:'archived')# UPDATE posts SET state = 'archived' WHERE (stamp < '2010-07-07')
You can provide arbitrary expressions when choosing what values to set:
posts.where(Sequel[:stamp]<Date.today-7).update(backup_number:Sequel[:backup_number]+1)# UPDATE posts SET backup_number = (backup_number + 1) WHERE (stamp < '2010-07-07'))))
As withdelete,update affects all rows in the dataset, sowhere first,update second:
# DO THIS:posts.where(Sequel[:stamp]<Date.today-7).update(state:'archived')# NOT THIS:posts.update(state:'archived').where(Sequel[:stamp]<Date.today-7)
Merging records using the SQL MERGE statement is done usingmerge* methods. You usemerge_using to specify the merge source and join conditions. You can usemerge_insert,merge_delete, and/ormerge_update to set the INSERT, DELETE, and UPDATE clauses for the merge.merge_insert takes the same arguments asinsert, andmerge_update takes the same arguments asupdate.merge_insert,merge_delete, andmerge_update can all be called with blocks, to set the conditions for the related INSERT, DELETE, or UPDATE.
Finally, after calling all of the othermerge_* methods, you callmerge to run the MERGE statement on the database.
ds =DB[:m1]merge_using(:m2,i1::i2).merge_insert(i1::i2,a:Sequel[:b]+11).merge_delete{a>30}.merge_update(i1:Sequel[:i1]+:i2+10,a:Sequel[:a]+:b+20)ds.merge# MERGE INTO m1 USING m2 ON (i1 = i2)# WHEN NOT MATCHED THEN INSERT (i1, a) VALUES (i2, (b + 11))# WHEN MATCHED AND (a > 30) THEN DELETE# WHEN MATCHED THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
If the block does not raise an exception, the transaction will be committed. If the block does raise an exception, the transaction will be rolled back, and the exception will be reraised. If you want to rollback the transaction and not raise an exception outside the block, you can raise theSequel::Rollback exception inside the block:
order_items =DB[:items].join(:order_items,item_id::id).where(order_id:1234)# SELECT * FROM items# INNER JOIN order_items ON (order_items.item_id = items.id)# WHERE (order_id = 1234)
The important thing to note here is that item_id is automatically qualified with the table being joined, and id is automatically qualified with the last table joined.
You can then do anything you like with the dataset:
order_total =order_items.sum(:price)# SELECT sum(price) FROM items# INNER JOIN order_items ON (order_items.item_id = items.id)# WHERE (order_id = 1234)
Note that the default selection in Sequel is*, which includes all columns in all joined tables. Because Sequel returns results as a hash keyed by column name symbols, if any tables have columns with the same name, this will clobber the columns in the returned hash. So when joining you are usually going to want to change the selection usingselect,select_all, and/orselect_append.
Sequel expects column names to be specified using symbols. In addition, returned hashes always use symbols as their keys. This allows you to freely mix literal values and column references in many cases. For example, the two following lines produce equivalent SQL:
items.where(x:1)# SELECT * FROM items WHERE (x = 1)items.where(1=>:x)# SELECT * FROM items WHERE (1 = x)"
Ruby strings are generally treated as SQL strings:
items.where(x:'x')# SELECT * FROM items WHERE (x = 'x')
A model class wraps a dataset, and an instance of that class wraps a single record in the dataset.
Model classes are defined as regular Ruby classes inheriting fromSequel::Model:
DB =Sequel.connect('sqlite://blog.db')classPost<Sequel::Modelend
When a model class is created, it parses the schema in the table from the database, and automatically sets up accessor methods for all of the columns in the table (Sequel::Model implements the active record pattern).
Sequel model classes assume that the table name is an underscored plural of the class name:
Post.table_name# => :posts
You can explicitly set the table name or even the dataset used:
If you pass a symbol to theSequel::Model method, it assumes you are referring to the table with the same name. You can also call it with a dataset, which will set the defaults for all retrievals for that model:
Model instances are identified by a primary key. Sequel queries the database to determine the primary key for each model. TheModel.[] method can be used to fetch records by their primary key:
post =Post[123]
Thepk method is used to retrieve the record’s primary key value:
post.pk# => 123
If you want to override which column(s) to use as the primary key, you can useset_primary_key:
You can also define a model class that does not have a primary key viano_primary_key, but then you lose the ability to easily update and delete records:
Post.no_primary_key
A single model instance can also be fetched by specifying a condition:
post =Post.first(title:'hello world')post =Post.first{num_comments<10}
The dataset for a model class returns rows of model instances instead of plain hashes:
DB[:posts].first.class# => HashPost.first.class# => Post
A model class forwards many methods to the underlying dataset. This means that you can use most of theDataset API to create customized queries that return model instances, e.g.:
Post.where(category:'ruby').each{|post|ppost}
You can also manipulate the records in the dataset:
You can read the record values as object attributes, assuming the attribute names are valid columns in the model’s dataset:
post.id# => 123post.title# => 'hello world'
If the record’s attributes names are not valid columns in the model’s dataset (maybe because you usedselect_append to add a computed value column), you can useModel#[] to access the values:
post[:id]# => 123post[:title]# => 'hello world'
You can also modify record values using attribute setters or the[]= method.
post.title ='hey there'post[:title] ='hey there'
That will just change the value for the object, it will not update the row in the database. To update the database row, call thesave method:
You can also set the values for multiple columns in a single method call, using one of the mass-assignment methods. See the mass assignment guide for details. For exampleset updates the model’s column values without saving:
post.set(title:'hey there',updated_by:'foo')
andupdate updates the model’s column values and then saves the changes to the database:
Note the use ofsuper if you define your own hook methods. Almost allSequel::Model class and instance methods (not just hook methods) can be overridden safely, but you have to make sure to callsuper when doing so, otherwise you risk breaking things.
For the example above, you should probably use a database trigger if you can. Hooks can be used for data integrity, but they will only enforce that integrity when you are modifying the database through model instances, and even then they are often subject to race conditions. It’s best to use database triggers and database constraints to enforce data integrity.
You can delete individual records by callingdelete ordestroy. The only difference between the two methods is thatdestroy invokesbefore_destroy andafter_destroy hook methods, whiledelete does not:
Records can also be deleted en-masse by callingdelete anddestroy on the model’s dataset. As stated above, you can specify filters for the deleted records:
Associations are used in order to specify relationships between model classes that reflect relationships between tables in the database, which are usually specified using foreign keys. You specify model associations via class methods:
many_to_one andone_to_one create a getter and setter for each model object:
post =Post.create(name:'hi!')post.author =Author.first(name:'Sharon')post.author
one_to_many andmany_to_many create a getter method, a method for adding an object to the association, a method for removing an object from the association, and a method for removing all associated objects from the association:
post =Post.create(name:'hi!')post.commentscomment =Comment.create(text:'hi')post.add_comment(comment)post.remove_comment(comment)post.remove_all_commentstag =Tag.create(tag:'interesting')post.add_tag(tag)post.remove_tag(tag)post.remove_all_tags
Note that the remove_* and remove_all_* methods do not delete the object from the database, they merely disassociate the associated object from the receiver.
All associations add a dataset method that can be used to further filter or reorder the returned objects, or modify all of them:
# Delete all of this post's comments from the databasepost.comments_dataset.destroy# Return all tags related to this post with no subscribers, ordered by the tag's namepost.tags_dataset.where(subscribers:0).order(:name).all
Associations can be eagerly loaded viaeager and the:eager association option. Eager loading is used when loading a group of objects. It loads all associated objects for all of the current objects in one query, instead of using a separate query to get the associated objects for each current object. Eager loading requires that you retrieve all model objects at once viaall (instead of individually byeach). Eager loading can be cascaded, loading association’s associated objects.
classPerson<Sequel::Modelone_to_many:posts,eager: [:tags]endclassPost<Sequel::Modelmany_to_one:personone_to_many:repliesmany_to_many:tagsendclassTag<Sequel::Modelmany_to_many:postsmany_to_many:repliesendclassReply<Sequel::Modelmany_to_one:personmany_to_one:postmany_to_many:tagsend# Eager loading via .eagerPost.eager(:person).all# eager is a dataset method, so it works with filters/orders/limits/etc.Post.where{topic>'M'}.order(:date).limit(5).eager(:person).allperson =Person.first# Eager loading via :eager (will eagerly load the tags for this person's posts)person.posts# These are equivalentPost.eager(:person,:tags).allPost.eager(:person).eager(:tags).all# Cascading via .eagerTag.eager(posts::replies).all# Will also grab all associated posts' tags (because of :eager)Reply.eager(person::posts).all# No depth limit (other than memory/stack), and will also grab posts' tags# Loads all people, their posts, their posts' tags, replies to those posts,# the person for each reply, the tag for each reply, and all posts and# replies that have that tag. Uses a total of 8 queries.Person.eager(posts: {replies: [:person, {tags: [:posts,:replies]}]}).all
In addition to usingeager, you can also useeager_graph, which will use a single query to get the object and all associated objects. This may be necessary if you want to filter or order the result set based on columns in associated tables. It works with cascading as well, the API is similar. Note that usingeager_graph to eagerly load multiple*_to_many associations will cause the result set to be a cartesian product, so you should be very careful with your filters when using it in that case.
You can dynamically customize the eagerly loaded dataset by using a proc. This proc is passed the dataset used for eager loading, and should return a modified copy of that dataset:
# Eagerly load only replies containing 'foo'Post.eager(replies:proc{|ds|ds.where(Sequel.like(text,'%foo%'))}).all
This also works when usingeager_graph, in which case the proc is called with dataset to graph into the current dataset:
You can dynamically customize eager loads for botheager andeager_graph while also cascading, by making the value a single entry hash with the proc as a key, and the cascaded associations as the value:
# Eagerly load only replies containing 'foo', and the person and tags for those repliesPost.eager(replies: {proc{|ds|ds.where(Sequel.like(text,'%foo%'))}=> [:person,:tags]}).all
You can use theassociation_join method to add a join to the model’s dataset based on the association:
Post.association_join(:author)# SELECT * FROM posts# INNER JOIN authors AS author ON (author.id = posts.author_id)
This comes with variants for different join types:
Post.association_left_join(:replies)# SELECT * FROM posts# LEFT JOIN replies ON (replies.post_id = posts.id)
Similar to the eager loading methods, you can use multiple associations and nested associations:
Post.association_join(:author,replies::person).all# SELECT * FROM posts# INNER JOIN authors AS author ON (author.id = posts.author_id)# INNER JOIN replies ON (replies.post_id = posts.id)# INNER JOIN people AS person ON (person.id = replies.person_id)
This allows you to have access to your model API from filtered datasets as well:
Post.where(category:'ruby').clean_boring# DELETE FROM posts WHERE ((category = 'ruby') AND (num_comments < 30))
Insidedataset_module blocks, there are numerous methods that support easy creation of dataset methods. Most of these methods are named after the dataset methods themselves, such asselect,order, andgroup:
classPost<Sequel::Modeldataset_moduledowhere(:with_few_comments,Sequel[:num_comments]<30)select:with_title_and_date,:id,:title,:post_dateorder:by_post_date,:post_datelimit:top10,10endendPost.with_few_comments.with_title_and_date.by_post_date.top10# SELECT id, title, post_date# FROM posts# ORDER BY post_date# LIMIT 10
One advantage of using these methods inside dataset_module blocks, instead of defining methods manually, is that the created methods will generally cache the resulting values and result in better performance.
You can define avalidate method for your model, whichsave will check before attempting to save the model in the database. If an attribute of the model isn’t valid, you should add an error message for that attribute to the model object’serrors. If an object has any errors added by the validate method,save will raise an error by default:
classPost<Sequel::Modeldefvalidatesupererrors.add(:name,"can't be empty")ifname.empty?errors.add(:written_on,"should be in the past")ifwritten_on>=Time.nowendend
Sequel fully supports the currently supported versions of Ruby (MRI) and JRuby. It may support unsupported versions of Ruby or JRuby, but such support may be dropped in any minor version if keeping it becomes a support issue. The minimum Ruby version required to run the current version of Sequel is 1.9.2, and the minimum JRuby version is 9.2.0.0 (due to the bigdecimal dependency).