ruby-on-rails rails - ¿Cómo obtener los últimos N registros con activerecord?





php includes (12)


Para la versión Rails 4 y superior:

Puedes intentar algo como esto si quieres la primera entrada más antigua

YourModel.order(id: :asc).limit(5).each do |d|

Puede intentar algo como esto si quiere las últimas entradas más recientes .

YourModel.order(id: :desc).limit(5).each do |d|

Con :limit en la consulta, obtendré los primeros N registros. ¿Cuál es la forma más fácil de obtener los últimos N registros?




En mi proyecto de carriles (rails 4.2) , uso

Model.last(10) # get the last 10 record order by id

y funciona.




Esta es la forma de Rails 3

SomeModel.last(5) # last 5 records in ascending order

SomeModel.last(5).reverse # last 5 records in descending order



Para Rails 5 (y probablemente Rails 4)

Malo:

Something.last(5)

porque:

Something.last(5).class
=> Array

asi que:

Something.last(50000).count

probablemente hará explotar tu memoria o demorará para siempre.

Buen enfoque:

Something.limit(5).order('id desc')

porque:

Something.limit(5).order('id desc').class
=> Image::ActiveRecord_Relation

Something.limit(5).order('id desc').to_sql
=> "SELECT  \"somethings\".* FROM \"somethings\" ORDER BY id desc LIMIT 5"

Este último es un alcance no evaluado. Puede encadenarlo o convertirlo en una matriz a través de .to_a . Asi que:

Something.limit(50000).order('id desc').count

... toma un segundo.




Si tiene un alcance predeterminado en su modelo que especifica un orden ascendente en Rails 3, deberá usar el orden en lugar del pedido según lo especificado por Arthur Neves arriba:

Something.limit(5).reorder('id desc')

o

Something.reorder('id desc').limit(5)



La solución está aquí:

SomeModel.last(5).reverse

Como los rieles son flojos, eventualmente llegarán a la base de datos con SQL como: "SELECT table . * FROM table ORDER BY table . id DESC LIMIT 5".




Digamos que N = 5 y su modelo es Message , puede hacer algo como esto:

Message.order(id: :asc).from(Message.all.order(id: :desc).limit(5), :messages)

Mira el sql:

SELECT "messages".* FROM (
  SELECT  "messages".* FROM "messages"  ORDER BY "messages"."created_at" DESC LIMIT 5
) messages  ORDER BY "messages"."created_at" ASC

La clave es la subselección. Primero debemos definir cuáles son los últimos mensajes que queremos y luego tenemos que ordenarlos en orden ascendente.




La nueva forma de hacerlo en rails 3.1 es SomeModel.limit(5).order('id desc')




Agregar un: parámetro de orden a la consulta




Una consulta de registro activa como esta creo que obtendría lo que desea ('Algo' es el nombre del modelo):

Something.find(:all, :order => "id desc", :limit => 5).reverse

editar : Como se señaló en los comentarios, de otra manera:

result = Something.find(:all, :order => "id desc", :limit => 5)

while !result.empty?
        puts result.pop
end



Sólo inténtalo:

Model.all.order("id asc").limit(5)



Ruby usa el case para escribir declaraciones de cambio.

Según los documentos de Ruby :

Las declaraciones de casos consisten en una condición opcional, que está en la posición de un argumento a case , y cero o más when cláusulas. La primera cláusula when para coincidir con la condición (o para evaluar la verdad booleana, si la condición es nula) "gana" y se ejecuta su stanza de código. El valor de la declaración de caso es el valor de la cláusula when éxito, o nil si no existe tal cláusula.

Una declaración de caso puede terminar con una cláusula else . Cada una when una declaración puede tener múltiples valores candidatos, separados por comas.

Ejemplo:

case x
when 1,2,3
  puts "1, 2, or 3"
when 10
  puts "10"
else
  puts "Some other number"
end

Versión más corta:

case x
when 1,2,3 then puts "1, 2, or 3"
when 10 then puts "10"
else puts "Some other number"
end

Y como este blog de Honeybadger describe Ruby Case;

Se puede utilizar con Ranges :

case 5
when (1..10)
  puts "case statements match inclusion in a range"
end

## => "case statements match inclusion in a range"

Se puede utilizar con Regex :

case "FOOBAR"
when /BAR$/
  puts "they can match regular expressions!"
end

## => "they can match regular expressions!"

Se puede utilizar con Procs y Lambdas :

case 40
when -> (n) { n.to_s == "40" }
  puts "lambdas!"
end

## => "lambdas"

Además, se puede utilizar con tus propias clases de partidos:

class Success
  def self.===(item)
    item.status >= 200 && item.status < 300
  end
end

class Empty
  def self.===(item)
    item.response_size == 0
  end
end

case http_response
when Empty
  puts "response was empty"
when Success
  puts "response was a success"
end






ruby-on-rails ruby activerecord