couchrest_model/lib/couchrest/core/database.rb

334 lines
11 KiB
Ruby
Raw Normal View History

require 'cgi'
2008-06-07 17:32:51 +02:00
require "base64"
2008-09-12 06:14:34 +02:00
module CouchRest
2008-03-18 19:37:10 +01:00
class Database
attr_reader :server, :host, :name, :root, :uri
attr_accessor :bulk_save_cache_limit
2008-09-08 00:28:20 +02:00
2008-10-14 10:07:48 +02:00
# Create a CouchRest::Database adapter for the supplied CouchRest::Server
# and database name.
#
2008-09-30 08:39:57 +02:00
# ==== Parameters
# server<CouchRest::Server>:: database host
# name<String>:: database name
#
def initialize(server, name)
2008-03-18 19:37:10 +01:00
@name = name
@server = server
@host = server.uri
@uri = "/#{name.gsub('/','%2F')}"
@root = host + uri
2008-10-14 01:46:48 +02:00
@streamer = Streamer.new(self)
@bulk_save_cache = []
@bulk_save_cache_limit = 500 # must be smaller than the uuid count
2008-03-18 19:37:10 +01:00
end
2008-09-30 08:39:57 +02:00
# returns the database's uri
2008-08-03 21:51:17 +02:00
def to_s
@root
2008-08-03 21:51:17 +02:00
end
2008-09-30 08:26:34 +02:00
# GET the database info from CouchDB
def info
CouchRest.get @root
end
2008-09-30 08:26:34 +02:00
# Query the <tt>_all_docs</tt> view. Accepts all the same arguments as view.
def documents(params = {})
keys = params.delete(:keys)
url = CouchRest.paramify_url "#{@root}/_all_docs", params
if keys
CouchRest.post(url, {:keys => keys})
else
CouchRest.get url
end
2008-03-19 16:57:20 +01:00
end
2009-05-09 04:00:39 +02:00
# load a set of documents by passing an array of ids
def get_bulk(ids)
documents(:keys => ids, :include_docs => true)
end
2009-05-14 05:44:57 +02:00
alias :bulk_load :get_bulk
2009-05-09 04:00:39 +02:00
2008-10-14 10:07:48 +02:00
# POST a temporary view function to CouchDB for querying. This is not
# recommended, as you don't get any performance benefit from CouchDB's
# materialized views. Can be quite slow on large databases.
def slow_view(funcs, params = {})
keys = params.delete(:keys)
funcs = funcs.merge({:keys => keys}) if keys
url = CouchRest.paramify_url "#{@root}/_temp_view", params
2009-07-14 10:43:40 +02:00
JSON.parse(HttpAbstraction.post(url, funcs.to_json, {"Content-Type" => 'application/json'}))
2008-03-20 02:10:16 +01:00
end
# backwards compatibility is a plus
alias :temp_view :slow_view
2008-03-20 02:10:16 +01:00
2008-10-14 10:07:48 +02:00
# Query a CouchDB view as defined by a <tt>_design</tt> document. Accepts
# paramaters as described in http://wiki.apache.org/couchdb/HttpViewApi
def view(name, params = {}, &block)
keys = params.delete(:keys)
2009-03-09 21:12:28 +01:00
name = name.split('/') # I think this will always be length == 2, but maybe not...
dname = name.shift
vname = name.join('/')
url = CouchRest.paramify_url "#{@root}/_design/#{dname}/_view/#{vname}", params
if keys
CouchRest.post(url, {:keys => keys})
else
2008-10-14 01:46:48 +02:00
if block_given?
2009-03-09 21:12:28 +01:00
@streamer.view("_design/#{dname}/_view/#{vname}", params, &block)
2008-10-14 01:46:48 +02:00
else
CouchRest.get url
end
end
2008-03-19 16:57:20 +01:00
end
2008-07-05 01:56:09 +02:00
2008-09-30 08:26:34 +02:00
# GET a document from CouchDB, by id. Returns a Ruby Hash.
2009-03-15 02:42:34 +01:00
def get(id, params = {})
2009-01-13 04:54:02 +01:00
slug = escape_docid(id)
url = CouchRest.paramify_url("#{@root}/#{slug}", params)
result = CouchRest.get(url)
return result unless result.is_a?(Hash)
doc = if /^_design/ =~ result["_id"]
Design.new(result)
2008-11-09 01:28:58 +01:00
else
Document.new(result)
2008-11-09 01:28:58 +01:00
end
doc.database = self
doc
2008-03-19 18:17:25 +01:00
end
2008-03-19 16:57:20 +01:00
2008-09-30 08:26:34 +02:00
# GET an attachment directly from CouchDB
2009-02-03 00:24:31 +01:00
def fetch_attachment(doc, name)
uri = url_for_attachment(doc, name)
2009-07-14 10:43:40 +02:00
HttpAbstraction.get uri
2008-06-07 17:32:51 +02:00
end
2008-10-01 02:22:54 +02:00
# PUT an attachment directly to CouchDB
def put_attachment(doc, name, file, options = {})
docid = escape_docid(doc['_id'])
name = CGI.escape(name)
uri = url_for_attachment(doc, name)
2009-07-14 10:43:40 +02:00
JSON.parse(HttpAbstraction.put(uri, file, options))
2008-10-01 02:22:54 +02:00
end
# DELETE an attachment directly from CouchDB
def delete_attachment(doc, name, force=false)
uri = url_for_attachment(doc, name)
2009-02-03 00:24:31 +01:00
# this needs a rev
begin
JSON.parse(HttpAbstraction.delete(uri))
rescue Exception => error
if force
# get over a 409
doc = get(doc['_id'])
uri = url_for_attachment(doc, name)
JSON.parse(HttpAbstraction.delete(uri))
else
error
end
end
end
2008-10-14 10:07:48 +02:00
# Save a document to CouchDB. This will use the <tt>_id</tt> field from
# the document as the id for PUT, or request a new UUID from CouchDB, if
# no <tt>_id</tt> is present on the document. IDs are attached to
# documents on the client side because POST has the curious property of
# being automatically retried by proxies in the event of network
# segmentation and lost responses.
#
# If <tt>bulk</tt> is true (false by default) the document is cached for bulk-saving later.
# Bulk saving happens automatically when #bulk_save_cache limit is exceded, or on the next non bulk save.
#
# If <tt>batch</tt> is true (false by default) the document is saved in
# batch mode, "used to achieve higher throughput at the cost of lower
# guarantees. When [...] sent using this option, it is not immediately
# written to disk. Instead it is stored in memory on a per-user basis for a
# second or so (or the number of docs in memory reaches a certain point).
# After the threshold has passed, the docs are committed to disk. Instead
# of waiting for the doc to be written to disk before responding, CouchDB
# sends an HTTP 202 Accepted response immediately. batch=ok is not suitable
# for crucial data, but it ideal for applications like logging which can
# accept the risk that a small proportion of updates could be lost due to a
# crash."
def save_doc(doc, bulk = false, batch = false)
2008-06-07 17:32:51 +02:00
if doc['_attachments']
doc['_attachments'] = encode_attachments(doc['_attachments'])
end
if bulk
@bulk_save_cache << doc
bulk_save if @bulk_save_cache.length >= @bulk_save_cache_limit
return {"ok" => true} # Compatibility with Document#save
elsif !bulk && @bulk_save_cache.length > 0
bulk_save
end
2008-11-09 01:28:58 +01:00
result = if doc['_id']
slug = escape_docid(doc['_id'])
begin
uri = "#{@root}/#{slug}"
uri << "?batch=ok" if batch
CouchRest.put uri, doc
2009-07-14 10:43:40 +02:00
rescue HttpAbstraction::ResourceNotFound
p "resource not found when saving even tho an id was passed"
slug = doc['_id'] = @server.next_uuid
CouchRest.put "#{@root}/#{slug}", doc
end
2008-03-19 16:57:20 +01:00
else
begin
slug = doc['_id'] = @server.next_uuid
CouchRest.put "#{@root}/#{slug}", doc
rescue #old version of couchdb
CouchRest.post @root, doc
end
2008-03-19 16:57:20 +01:00
end
2008-11-09 01:28:58 +01:00
if result['ok']
doc['_id'] = result['id']
doc['_rev'] = result['rev']
doc.database = self if doc.respond_to?(:database=)
end
result
2008-03-19 16:57:20 +01:00
end
# Save a document to CouchDB in bulk mode. See #save_doc's +bulk+ argument.
def bulk_save_doc(doc)
save_doc(doc, true)
end
# Save a document to CouchDB in batch mode. See #save_doc's +batch+ argument.
def batch_save_doc(doc)
save_doc(doc, false, true)
end
2008-10-14 10:07:48 +02:00
# POST an array of documents to CouchDB. If any of the documents are
# missing ids, supply one from the uuid cache.
#
# If called with no arguments, bulk saves the cache of documents to be bulk saved.
def bulk_save(docs = nil, use_uuids = true)
if docs.nil?
docs = @bulk_save_cache
@bulk_save_cache = []
end
if (use_uuids)
ids, noids = docs.partition{|d|d['_id']}
uuid_count = [noids.length, @server.uuid_batch_count].max
noids.each do |doc|
nextid = @server.next_uuid(uuid_count) rescue nil
doc['_id'] = nextid if nextid
end
end
CouchRest.post "#{@root}/_bulk_docs", {:docs => docs}
2008-03-20 00:38:07 +01:00
end
alias :bulk_delete :bulk_save
2008-03-20 00:38:07 +01:00
2008-10-14 10:07:48 +02:00
# DELETE the document from CouchDB that has the given <tt>_id</tt> and
# <tt>_rev</tt>.
#
# If <tt>bulk</tt> is true (false by default) the deletion is recorded for bulk-saving (bulk-deletion :) later.
# Bulk saving happens automatically when #bulk_save_cache limit is exceded, or on the next non bulk save.
def delete_doc(doc, bulk = false)
2009-01-13 05:01:37 +01:00
raise ArgumentError, "_id and _rev required for deleting" unless doc['_id'] && doc['_rev']
if bulk
@bulk_save_cache << { '_id' => doc['_id'], '_rev' => doc['_rev'], '_deleted' => true }
return bulk_save if @bulk_save_cache.length >= @bulk_save_cache_limit
return { "ok" => true } # Mimic the non-deferred version
end
2009-01-13 04:54:02 +01:00
slug = escape_docid(doc['_id'])
CouchRest.delete "#{@root}/#{slug}?rev=#{doc['_rev']}"
end
# COPY an existing document to a new id. If the destination id currently exists, a rev must be provided.
# <tt>dest</tt> can take one of two forms if overwriting: "id_to_overwrite?rev=revision" or the actual doc
# hash with a '_rev' key
def copy_doc(doc, dest)
raise ArgumentError, "_id is required for copying" unless doc['_id']
2009-01-13 04:54:02 +01:00
slug = escape_docid(doc['_id'])
destination = if dest.respond_to?(:has_key?) && dest['_id'] && dest['_rev']
"#{dest['_id']}?rev=#{dest['_rev']}"
else
dest
end
CouchRest.copy "#{@root}/#{slug}", destination
end
2008-12-15 00:29:15 +01:00
# Compact the database, removing old document revisions and optimizing space use.
def compact!
CouchRest.post "#{@root}/_compact"
end
# Create the database
def create!
bool = server.create_db(@name) rescue false
bool && true
end
# Delete and re create the database
def recreate!
delete!
create!
2009-07-14 10:43:40 +02:00
rescue HttpAbstraction::ResourceNotFound
ensure
create!
2008-12-15 00:29:15 +01:00
end
# Replicates via "pulling" from another database to this database. Makes no attempt to deal with conflicts.
def replicate_from other_db
raise ArgumentError, "must provide a CouchReset::Database" unless other_db.kind_of?(CouchRest::Database)
CouchRest.post "#{@host}/_replicate", :source => other_db.root, :target => name
end
# Replicates via "pushing" to another database. Makes no attempt to deal with conflicts.
def replicate_to other_db
raise ArgumentError, "must provide a CouchReset::Database" unless other_db.kind_of?(CouchRest::Database)
CouchRest.post "#{@host}/_replicate", :target => other_db.root, :source => name
end
2008-10-14 10:07:48 +02:00
# DELETE the database itself. This is not undoable and could be rather
# catastrophic. Use with care!
2008-03-18 19:37:10 +01:00
def delete!
clear_extended_doc_fresh_cache
CouchRest.delete @root
2008-03-18 19:37:10 +01:00
end
2008-06-07 17:32:51 +02:00
private
def clear_extended_doc_fresh_cache
2009-05-28 08:59:43 +02:00
::CouchRest::ExtendedDocument.subclasses.each{|klass| klass.design_doc_fresh = false if klass.respond_to?(:design_doc_fresh=) }
end
def uri_for_attachment(doc, name)
2009-02-03 00:24:31 +01:00
if doc.is_a?(String)
puts "CouchRest::Database#fetch_attachment will eventually require a doc as the first argument, not a doc.id"
docid = doc
rev = nil
else
docid = doc['_id']
rev = doc['_rev']
end
docid = escape_docid(docid)
name = CGI.escape(name)
2009-02-03 00:24:31 +01:00
rev = "?rev=#{doc['_rev']}" if rev
"/#{docid}/#{name}#{rev}"
end
def url_for_attachment(doc, name)
@root + uri_for_attachment(doc, name)
end
2009-01-13 04:54:02 +01:00
def escape_docid id
/^_design\/(.*)/ =~ id ? "_design/#{CGI.escape($1)}" : CGI.escape(id)
2009-01-13 04:50:00 +01:00
end
def encode_attachments(attachments)
2008-06-07 17:32:51 +02:00
attachments.each do |k,v|
2008-06-12 17:40:52 +02:00
next if v['stub']
2008-06-07 18:05:29 +02:00
v['data'] = base64(v['data'])
2008-06-07 17:32:51 +02:00
end
2008-06-07 18:05:29 +02:00
attachments
2008-06-07 17:32:51 +02:00
end
def base64(data)
2008-06-07 17:32:51 +02:00
Base64.encode64(data).gsub(/\s/,'')
end
2008-03-18 19:37:10 +01:00
end
2008-06-20 23:26:26 +02:00
end