Module: Sequel::Model::DatasetMethods

Defined in:
lib/sequel/model/base.rb

Overview

Dataset methods are methods that the model class extends its dataset with in the call to set_dataset.

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#model ⇒ Object

The model class associated with this dataset

Artist.dataset.model # => Artist



1918
1919
1920
 
# File 'lib/sequel/model/base.rb', line 1918

def model
  @model
end

Instance Method Details

#[](*args) ⇒ Object

Assume if a single integer is given that it is a lookup by primary key, and call with_pk with the argument.

Artist.dataset[1] # SELECT * FROM artists WHERE (id = 1) LIMIT 1



1924
1925
1926
1927
1928
1929
1930
 
# File 'lib/sequel/model/base.rb', line 1924

def [](*args)
  if args.length == 1 && (i = args.at(0)) && i.is_a?(Integer)
    with_pk(i)
  else
    super
  end
end

#destroy ⇒ Object

Destroy each row in the dataset by instantiating it and then calling destroy on the resulting model object. This isn’t as fast as deleting the dataset, which does a single SQL call, but this runs any destroy hooks on each object in the dataset.

Artist.dataset.destroy
# DELETE FROM artists WHERE (id = 1)
# DELETE FROM artists WHERE (id = 2)
# ...



1941
1942
1943
1944
 
# File 'lib/sequel/model/base.rb', line 1941

def destroy
  pr = proc{all{|r| r.destroy}.length}
  model.use_transactions ? @db.transaction(:server=>opts[:server], &pr) : pr.call
end

#graph(table, *args, &block) ⇒ Object

Allow Sequel::Model classes to be used as dataset arguments when graphing:

Artist.graph(Album, :artist_id=>id)
# SELECT artists.id, artists.name, albums.id AS albums_id, albums.artist_id, albums.name AS albums_name
# FROM artists LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)



1951
1952
1953
1954
1955
1956
1957
 
# File 'lib/sequel/model/base.rb', line 1951

def graph(table, *args, &block)
  if table.is_a?(Class) && table < Sequel::Model
    super(table.dataset, *args, &block)
  else
    super
  end
end

#insert_sql(*values) ⇒ Object

Handle Sequel::Model instances when inserting, using the model instance’s values for the insert, unless the model instance can be used directly in SQL.

Album.insert(Album.load(:name=>'A'))
# INSERT INTO albums (name) VALUES ('A')



1965
1966
1967
1968
1969
1970
1971
 
# File 'lib/sequel/model/base.rb', line 1965

def insert_sql(*values)
  if values.size == 1 && (v = values.at(0)).is_a?(Sequel::Model) && !v.respond_to?(:sql_literal_append)
    super(v.to_hash)
  else
    super
  end
end

#join_table(type, table, *args, &block) ⇒ Object

Allow Sequel::Model classes to be used as table name arguments in dataset join methods:

Artist.join(Album, :artist_id=>id)
# SELECT * FROM artists INNER JOIN albums ON (albums.artist_id = artists.id)



1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
 
# File 'lib/sequel/model/base.rb', line 1978

def join_table(type, table, *args, &block)
  if table.is_a?(Class) && table < Sequel::Model
    if table.dataset.simple_select_all?
      super(type, table.table_name, *args, &block)
    else
      super(type, table.dataset, *args, &block)
    end
  else
    super
  end
end

#last(*a, &block) ⇒ Object

If there is no order already defined on this dataset, order it by the primary key and call last.

Album.last
# SELECT * FROM albums ORDER BY id DESC LIMIT 1



1995
1996
1997
1998
1999
2000
2001
 
# File 'lib/sequel/model/base.rb', line 1995

def last(*a, &block)
  if opts[:order].nil? && model && (pk = model.primary_key)
    order(*pk).last(*a, &block)
  else
    super
  end
end

#paged_each(*a, &block) ⇒ Object

If there is no order already defined on this dataset, order it by the primary key and call paged_each.

Album.paged_each{|row| ...}
# SELECT * FROM albums ORDER BY id LIMIT 1000 OFFSET 0
# SELECT * FROM albums ORDER BY id LIMIT 1000 OFFSET 1000
# SELECT * FROM albums ORDER BY id LIMIT 1000 OFFSET 2000
# ...



2011
2012
2013
2014
2015
2016
2017
 
# File 'lib/sequel/model/base.rb', line 2011

def paged_each(*a, &block)
  if opts[:order].nil? && model && (pk = model.primary_key)
    order(*pk).paged_each(*a, &block)
  else
    super
  end
end

#to_hash(key_column = nil, value_column = nil) ⇒ Object

This allows you to call to_hash without any arguments, which will result in a hash with the primary key value being the key and the model object being the value.

Artist.dataset.to_hash # SELECT * FROM artists
# => {1=>#<Artist {:id=>1, ...}>,
#     2=>#<Artist {:id=>2, ...}>,
#     ...}



2027
2028
2029
2030
2031
2032
2033
2034
 
# File 'lib/sequel/model/base.rb', line 2027

def to_hash(key_column=nil, value_column=nil)
  if key_column
    super
  else
    raise(Sequel::Error, "No primary key for model") unless model && (pk = model.primary_key)
    super(pk, value_column) 
  end
end

#with_pk(pk) ⇒ Object

Given a primary key value, return the first record in the dataset with that primary key value. If no records matches, returns nil.

# Single primary key
Artist.dataset.with_pk(1) # SELECT * FROM artists WHERE (id = 1) LIMIT 1

# Composite primary key
Artist.dataset.with_pk([1, 2]) # SELECT * FROM artists
                               # WHERE ((id1 = 1) AND (id2 = 2)) LIMIT 1



2045
2046
2047
 
# File 'lib/sequel/model/base.rb', line 2045

def with_pk(pk)
  first(model.qualified_primary_key_hash(pk))
end

#with_pk!(pk) ⇒ Object

Same as with_pk, but raises NoMatchingRow instead of returning nil if no row matches.



2051
2052
2053
 
# File 'lib/sequel/model/base.rb', line 2051

def with_pk!(pk)
  with_pk(pk) || raise(NoMatchingRow)
end