rails常用数据库查询操作、方法浅析

2024-04-10 21:55:04 385

1、获取数据

获取第一条、最后一条记录


Model.first

Model.first(options)

Model.find(:first,options)

Model.last

Model.last(options)

Model.find(:last,options)

通过id获取记录


Model.find(1,10,options)

Model.find([1,10],options)

.findall


Model.all(options)

对一组数据进行相同操作


User.all.eachdo|user|

   NewsLetter.weekly_deliver(user)

end

如果表记录数比较大，这种方式比较耗资源，因为它会一次载入整个表的数据。改用以下这种方式，它每次只载入1000行，然后逐步yield完整个表


User.find_eachdo|user|

   NewsLetter.weekly_deliver(user)

end

自定义方式，find_each接受和find同样的options


User.find_each(:batch_size=>5000,:start=>2000)do|user|

   NewsLetter.weekly_deliver(user)

end

find_in_batches，和find_each相似，但它yield时传递的是model对象数组，而不是单个model对象


Invoice.find_in_batches(:include=>:invoice_lines)do|invoices|

   export.add_invoices(invoices)

end

2、查询条件

通过替换？来传递条件值，可避免SQL注入


Client.first(:conditions=>["orders_count=?",params[:orders])

symbol占位条件


Client.all(:conditions=>["created_at>=:start_dateANDcreated_at<=:end_date",{:start_date=>params[:start_date],:end_date=>params[:end_date]}])

范围条件in(集合)


Client.all(:conditions=>["created_atIN(?)",(params[:start_date].to_date)..(params[:end_date].to_date])

生成sql


SELECT*FROMusersWHERE(created_atIN('2007-12-31','2008-01-01','2008-01-02','2008-01-03','2008-01-04','2008-01-05','2008-01-06','2008-01-07','2008-01-08'))

如果要生成日期时间，再加上.to_time

params[:start_date].to_date.to_time，生成2007-12-0100:00:00格式

有上数据库会在以上条件中报错，如Mysql会报查询语句过长的错误，此时可以改成created_at>?ANDcreated_at<?的形式

Hash条件


Client.all(:conditions=>{:locked=>true})

带范围条件


Client.all(:conditons=>{:created=>(Time.now.midnight-1.day)..Time.now.midnight})

生成sql


SELECT*FROMclientsWHERE(clients.created_atBETWEEN'2008-12-2100:00:00'AND'2008-12-2200:00:00')

集合条件


Client.all(:conditons=>{:orders_count=>[1,3,5])

生成sql


SELECT*FROMclientsWHERE(clients.orders_countIN(1,3,5))

3、查询选项

排序


#单个排序

Client.all(:order=>"created_atASC")

#多个排序

Client.all(:order=>"orders_countASC,created_atDESC")

返回指定字段


Client.all(:select=>"viewable_by,locked")

#使用函数

Client.all(:select=>"DISTINCT(name)")

限定和偏移LimitandOffset


Client.all(:limit=>5)

#生成

SELECT*FROMclientsLIMIT5

Client.all(:limit=>5,:offset=>5)

#生成

SELECT*FROMclientsLIMIT5,5

Group分组


Order.all(:group=>"date(created_at)",:order=>"created_at")

生成sql

SELECT*FROMordersGROUPBYdate(created_at)

Having


Order.all(:group=>"date(created_at)",:having=>["created_at>?",1.month.ago)

生成sql

SELECT*FROMordersGROUPBYdate(created_at)HAVINGcreated_at>'2009-01-15'

只读


client=Client.first(:readonly=>true)

client.locked=false

client.save

#对只读对象进行保存将会触发ActiveRecord::ReadOnlyRecord异常

更新时锁定记录

乐观锁OptimisticLocking

为使用乐观锁，须在表里建一个lock_version的字段，每次更新记录时，ActiveRecord自动递增lock_version的值，


c1=Client.find(1)c2=Client.find(1)c1.name="Michael"c1.savec2.name="shouldfail"c2.save#RaisesaActiveRecord::StaleObjectError

备注：Youmustensurethatyourdatabaseschemadefaultsthelock_versioncolumnto0.

ThisbehaviorcanbeturnedoffbysettingActiveRecord::Base.lock_optimistically=false.

指定乐观锁字段名


classClient<ActiveRecord::Baseset_locking_column:lock_client_columnend

悲观锁PessimisticLocking
悲观锁定由数据库直接提供


Item.transactiondo

   i=Item.first(:lock=>true)

   i.name='Jones'

   i.save

end

Mysql执行返回

SQL(0.2ms)BEGINItemLoad(0.3ms)SELECT*FROM`items`LIMIT1FORUPDATEItemUpdate(0.4ms)UPDATE`items`SET`updated_at`='2009-02-0718:05:56',`name`='Jones'WHERE`id`=1SQL(0.8ms)COMMIT

为特定数据库加入原始的lock声明
为Mysql的锁定声明为共享模式，即锁定时仍然可读

Item.transactiondo i=Item.find(1,:lock=>"LOCKINSHAREMODE") i.increment!(:views)end

4、关联表


Client.all(:joins=>"LEFTOUTERJOINaddressONaddresses.client_id=clients.id')

生成sql

SELECTclients.*FROMclientsLEFTOUTERJOINaddressesONaddresses.client_id=clients.id

使用Array、Hash、NamedAssociations关联表
有如下model


classCategory<ActiveRecord::Base

   has_many:posts

end

classPost<ActiveRecord::Base

   belongs_to:category

   has_many:comments

   has_many:tags

end

classComments<ActiveRecord::Base

   belongs_to:post

   has_one:guest

end

classGuest<ActiveRecord::Base

   belongs_to:comment

end


#关联一个关系

Category.all:joins=>:posts

#关联多个关系

Post.all:joins=>[:category,:comments]

#嵌套关联

Category.all:joins=>{:posts=>[{:comments=>:guest},:tags]}

为关联查询结果设定条件


time_range=(Time.now.midnight-1.day)..Time.now.midnightClient.all:joins=>:orders,:conditions=>{'orders.created_at'=>time_ran

#或者

time_range=(Time.now.midnight-1.day)..Time.now.midnightClient.all:joins=>:orders,:conditions=>{:orders=>{:created_at=>time_range}}

5、优化载入
以下代码，需要执行1+10次sql


clients=Client.all(:limit=>10)clients.eachdo|client|

   putsclient.address.postcode

end

优化：


clients=Client.all(:include=>:address,:limit=>10)

clients.eachdo|client|

   putsclient.address.postcode

end

一次性载入post的所有分类和评论


Post.all:include=>[:category,:comments]

载入category为1的所有post和cooment及tag


Category.find1,:include=>{:posts=>[{:comments=>:guest},:tags]}

6、动态查询


Client.find_by_name("Ryan")

Client.find_all_by_name("Ryan")

#！方法，没有记录时抛出ActiveRecord::RecordNotFound异常

Client.find_by_name!("Ryan")

#查询多个字段

Client.find_by_name_and_locked("Ryan",true)

#查询不到时就创建并保存

Client.find_or_create_by_name(params[:name])

#查询不到时创建一个实例，但不保存

Client.find_or_initialize_by_name('Ryan')

7、find_by_sql


Client.find_by_sql("SELECT*FROMclientsINNERJOINordersONclients.id=orders.client_idORDERclients.created_atdesc")

8、select_all
和find_by_sql类似，但不会用model实例化返回记录，你会得到一个hash数组


Client.connection.select_all("SELECT*FROMclientsWHEREid='1'")

9、判断记录是否存在


#通过id来查询

Client.exists?(1)

Client.exists?(1,2,3)

#or

Client.exists?([1,2,3])

#通过其他条件来查询

Client.exists?(:conditions=>"first_name='Ryan'")

#没有参数时，则：表是空的?false:true

Client.exists?

10、计算


#求结果集条数

Client.count(:conditons=>"first_name='Ryan'")

#求某个字段非空白的条数

Client.count(:age)

#平均值

Client.average("orders_count")

#求最小值

Client.minimum("age")

#求最大值

Client.maximum("age")

#求和

Client.sum("orders_count")

rails常用数据库查询操作、方法浅析

热门推荐

随机推荐