class Arango::Database

Attributes

cache_name[R]

DEFINE ===

id[R]

DEFINE ===

isSystem[R]

DEFINE ===

name[RW]
path[R]

DEFINE ===

server[R]

DEFINE ===

Public Class Methods

new(*args) click to toggle source
Calls superclass method
# File lib/Database.rb, line 9
def self.new(*args)
  hash = args[0]
  super unless hash.is_a?(Hash)
  server = hash[:server]
  if server.is_a?(Arango::Server) && server.active_cache
    cache_name = hash[:name]
    cached = server.cache.cache.dig(:database, cache_name)
    if cached.nil?
      hash[:cache_name] = cache_name
      return super
    else
      return cached
    end
  end
  super
end
new(name:, server:, cache_name: nil) click to toggle source
# File lib/Database.rb, line 26
def initialize(name:, server:, cache_name: nil)
  assign_server(server)
  unless cache_name.nil?
    @cache_name = cache_name
    @server.cache.save(:database, cache_name, self)
  end
  @name = name
  @server = server
  @isSystem = nil
  @path = nil
  @id = nil
end

Public Instance Methods

[](name) click to toggle source

COLLECTION ==

# File lib/Database.rb, line 109
def [](name)
  Arango::Collection.new(name: name, database: self)
end
addUserAccess(grant:, user:) click to toggle source
# File lib/Database.rb, line 360
def addUserAccess(grant:, user:)
  user = check_user(user)
  user.addDatabaseAccess(grant: grant, database: @name)
end
aql(query:, count: nil, batchSize: nil, cache: nil, memoryLimit: nil, ttl: nil, bindVars: nil, failOnWarning: nil, profile: nil, maxTransactionSize: nil, skipInaccessibleCollections: nil, maxWarningCount: nil, intermediateCommitCount: nil, satelliteSyncWait: nil, fullCount: nil, intermediateCommitSize: nil, optimizer_rules: nil, maxPlans: nil) click to toggle source

AQL ===

# File lib/Database.rb, line 198
def aql(query:, count: nil, batchSize: nil, cache: nil, memoryLimit: nil,
  ttl: nil, bindVars: nil, failOnWarning: nil, profile: nil,
  maxTransactionSize: nil, skipInaccessibleCollections: nil,
  maxWarningCount: nil, intermediateCommitCount: nil,
  satelliteSyncWait: nil, fullCount: nil, intermediateCommitSize: nil,
  optimizer_rules: nil, maxPlans: nil)
  Arango::AQL.new(query: query, database: self, count: count,
    batchSize: batchSize, cache: cache, memoryLimit: memoryLimit, ttl: ttl,
    bindVars: bindVars, failOnWarning: failOnWarning, profile: profile,
    maxTransactionSize: maxTransactionSize,
    skipInaccessibleCollections: skipInaccessibleCollections,
    maxWarningCount: maxWarningCount,
    intermediateCommitCount: intermediateCommitCount,
    satelliteSyncWait: satelliteSyncWait, fullCount: fullCount,
    intermediateCommitSize: intermediateCommitSize,
    optimizer_rules: optimizer_rules, maxPlans: maxPlans)
end
aqlFunctions(namespace: nil) click to toggle source

AQL FUNCTION ===

# File lib/Database.rb, line 218
def aqlFunctions(namespace: nil)
  request("GET", "_api/aqlfunction", query: {"namespace": namespace}, key: :result)
end
assign_attributes(result) click to toggle source

GET ===

# File lib/Database.rb, line 71
def assign_attributes(result)
  return unless result.is_a?(Hash)
  @name     = result[:name]
  @isSystem = result[:isSystem]
  @path     = result[:path]
  @id       = result[:id]
  if @server.active_cache && @cache_name.nil?
    @cache_name = result[:name]
    @server.cache.save(:database, @cache_name, self)
  end
end
changePropertyQueryCache(mode:, maxResults: nil) click to toggle source
# File lib/Database.rb, line 190
def changePropertyQueryCache(mode:, maxResults: nil)
  satisfy_category?(mode, ["off", "on", "demand"])
  body = { "mode": mode, "maxResults": maxResults }
  database.request("PUT", "_api/query-cache/properties", body: body)
end
changeQueryProperties(slowQueryThreshold: nil, enabled: nil, maxSlowQueries: nil, trackSlowQueries: nil, maxQueryStringLength: nil, trackBindVars: nil) click to toggle source
# File lib/Database.rb, line 149
def changeQueryProperties(slowQueryThreshold: nil, enabled: nil, maxSlowQueries: nil,
  trackSlowQueries: nil, maxQueryStringLength: nil, trackBindVars: nil)
  body = {
    "slowQueryThreshold":   slowQueryThreshold,
    "enabled":              enabled,
    "maxSlowQueries":       maxSlowQueries,
    "trackSlowQueries":     trackSlowQueries,
    "maxQueryStringLength": maxQueryStringLength,
    "trackBindVars":        trackBindVars
  }
  request("PUT", "_api/query/properties", body: body)
end
clearQueryCache() click to toggle source

QUERY CACHE ===

# File lib/Database.rb, line 177
def clearQueryCache
  result = request("DELETE", "_api/query-cache")
  return return_delete(result)
end
clusterInventory(includeSystem: nil) click to toggle source
# File lib/Database.rb, line 243
def clusterInventory(includeSystem: nil)
  query = { "includeSystem": includeSystem }
  request("GET", "_api/replication/clusterInventory", query: query)
end
collection(name:, body: {}, type: :document) click to toggle source
# File lib/Database.rb, line 113
def collection(name:, body: {}, type: :document)
  Arango::Collection.new(name: name, database: self, body: body, type: type)
end
collections(excludeSystem: true) click to toggle source
# File lib/Database.rb, line 117
def collections(excludeSystem: true)
  query = { "excludeSystem": excludeSystem }
  result = request("GET", "_api/collection", query: query)
  return result if return_directly?(result)
  result[:result].map do |x|
    Arango::Collection.new(database: self, name: x[:name], body: x )
  end
end
create(name: @name, users: nil) click to toggle source

POST ===

# File lib/Database.rb, line 92
def create(name: @name, users: nil)
  body = {
    "name":  name,
    "users": users
  }
  result = @server.request("POST", "_api/database", body: body, key: :result)
  return return_directly?(result) ? result : self
end
createAqlFunction(code:, name:, isDeterministic: nil) click to toggle source
# File lib/Database.rb, line 222
def createAqlFunction(code:, name:, isDeterministic: nil)
  body = { "code": code, "name": name, "isDeterministic": isDeterministic }
  request("POST", "_api/aqlfunction", body: body)
end
current()
Alias for: retrieve
currentQuery() click to toggle source
# File lib/Database.rb, line 162
def currentQuery
  request("GET", "_api/query/current")
end
deleteAqlFunction(name:) click to toggle source
# File lib/Database.rb, line 227
def deleteAqlFunction(name:)
  result = request("DELETE", "_api/aqlfunction/#{name}")
  return return_delete(result)
end
destroy() click to toggle source

DELETE ==

# File lib/Database.rb, line 103
def destroy
  @server.request("DELETE", "_api/database/#{@name}", key: :result)
end
foxx(body: {}, mount:, development: nil, legacy: nil, provides: nil, name: nil, version: nil, type: "application/json", setup: nil, teardown: nil) click to toggle source

FOXX ===

# File lib/Database.rb, line 335
def foxx(body: {}, mount:, development: nil, legacy: nil, provides: nil,
  name: nil, version: nil, type: "application/json", setup: nil,
  teardown: nil)
  Arango::Foxx.new(database: self, body: body, mount: mount,
    development: development, legacy: legacy, provides: provides,
    name: name, version: version, type: type, setup: setup,
    teardown: teardown)
end
foxxes() click to toggle source
# File lib/Database.rb, line 344
def foxxes
  result = request("GET", "_api/foxx")
  return result if return_directly?(result)
  result.map do |fox|
    Arango::Foxx.new(database: self, mount: fox[:mount], body: fox)
  end
end
graph(name:, edgeDefinitions: [], orphanCollections: [], body: {}) click to toggle source
# File lib/Database.rb, line 136
def graph(name:, edgeDefinitions: [], orphanCollections: [],
  body: {})
  Arango::Graph.new(name: name, database: self,
    edgeDefinitions: edgeDefinitions,
    orphanCollections: orphanCollections, body: body)
end
graphs() click to toggle source

GRAPH ==

# File lib/Database.rb, line 128
def graphs
  result = request("GET", "_api/gharial")
  return result if return_directly?(result)
  result[:graphs].map do |graph|
    Arango::Graph.new(database: self, name: graph[:_key], body: graph)
  end
end
inventory(includeSystem: nil, global: nil, batchId:) click to toggle source

REPLICATION ===

# File lib/Database.rb, line 234
def inventory(includeSystem: nil, global: nil, batchId:)
  query = {
    "includeSystem": includeSystem,
    "global": global,
    "batchId": batchId
  }
  request("GET", "_api/replication/inventory", query: query)
end
lastTick() click to toggle source
# File lib/Database.rb, line 278
def lastTick
  request("GET", "_api/wal/lastTick")
end
logger() click to toggle source
# File lib/Database.rb, line 248
def logger
  request("GET", "_api/replication/logger-state")
end
loggerFirstTick() click to toggle source
# File lib/Database.rb, line 262
def loggerFirstTick
  request("GET", "_api/replication/logger-first-tick", key: :firstTick)
end
loggerFollow(from: nil, to: nil, chunkSize: nil, includeSystem: nil) click to toggle source
# File lib/Database.rb, line 252
def loggerFollow(from: nil, to: nil, chunkSize: nil, includeSystem: nil)
  query = {
    "from": from,
    "to":   to,
    "chunkSize":     chunkSize,
    "includeSystem": includeSystem
  }
  request("GET", "_api/replication/logger-follow", query: query)
end
loggerRangeTick() click to toggle source
# File lib/Database.rb, line 266
def loggerRangeTick
  request("GET", "_api/replication/logger-tick-ranges")
end
propertyQueryCache() click to toggle source
# File lib/Database.rb, line 186
def propertyQueryCache
  request("GET", "_api/query-cache/properties")
end
queryProperties() click to toggle source

QUERY ==

# File lib/Database.rb, line 145
def queryProperties
  request("GET", "_api/query/properties")
end
range() click to toggle source
# File lib/Database.rb, line 274
def range
  request("GET", "_api/wal/range")
end
replication(master:, includeSystem: true, initialSyncMaxWaitTime: nil, incremental: nil, restrictCollections: nil, connectTimeout: nil, autoResync: nil, idleMinWaitTime: nil, requestTimeout: nil, requireFromPresent: nil, idleMaxWaitTime: nil, restrictType: nil, maxConnectRetries: nil, adaptivePolling: nil, connectionRetryWaitTime: nil, autoResyncRetries: nil, chunkSize: nil, verbose: nil) click to toggle source
# File lib/Database.rb, line 295
def replication(master:, includeSystem: true,
  initialSyncMaxWaitTime: nil, incremental: nil,
  restrictCollections: nil, connectTimeout: nil,
  autoResync: nil, idleMinWaitTime: nil, requestTimeout: nil,
  requireFromPresent: nil, idleMaxWaitTime: nil, restrictType: nil,
  maxConnectRetries: nil, adaptivePolling: nil,
  connectionRetryWaitTime: nil, autoResyncRetries: nil, chunkSize: nil,
  verbose: nil)
  Arango::Replication.new(slave: self, master: master, includeSystem: includeSystem,
    initialSyncMaxWaitTime: initialSyncMaxWaitTime, incremental: incremental,
    restrictCollections: restrictCollections, connectTimeout: connectTimeout,
    autoResync: autoResync, idleMinWaitTime: idleMinWaitTime,
    requestTimeout: requestTimeout, requireFromPresent: requireFromPresent, idleMaxWaitTime: idleMaxWaitTime, restrictType: restrictType,
    maxConnectRetries: maxConnectRetries, adaptivePolling: adaptivePolling,
    connectionRetryWaitTime: connectionRetryWaitTime,
    autoResyncRetries: autoResyncRetries, chunkSize: chunkSize,
    verbose: verbose)
end
replication_as_master(slave:, includeSystem: true, initialSyncMaxWaitTime: nil, incremental: nil, restrictCollections: nil, connectTimeout: nil, autoResync: nil, idleMinWaitTime: nil, requestTimeout: nil, requireFromPresent: nil, idleMaxWaitTime: nil, restrictType: nil, maxConnectRetries: nil, adaptivePolling: nil, connectionRetryWaitTime: nil, autoResyncRetries: nil, chunkSize: nil, verbose: nil) click to toggle source
# File lib/Database.rb, line 314
def replication_as_master(slave:, includeSystem: true,
  initialSyncMaxWaitTime: nil, incremental: nil,
  restrictCollections: nil, connectTimeout: nil,
  autoResync: nil, idleMinWaitTime: nil, requestTimeout: nil,
  requireFromPresent: nil, idleMaxWaitTime: nil, restrictType: nil,
  maxConnectRetries: nil, adaptivePolling: nil,
  connectionRetryWaitTime: nil, autoResyncRetries: nil, chunkSize: nil,
  verbose: nil)
  Arango::Replication.new(master: self, slave: slave, includeSystem: includeSystem,
    initialSyncMaxWaitTime: initialSyncMaxWaitTime, incremental: incremental,
    restrictCollections: restrictCollections, connectTimeout: connectTimeout,
    autoResync: autoResync, idleMinWaitTime: idleMinWaitTime,
    requestTimeout: requestTimeout, requireFromPresent: requireFromPresent, idleMaxWaitTime: idleMaxWaitTime, restrictType: restrictType,
    maxConnectRetries: maxConnectRetries, adaptivePolling: adaptivePolling,
    connectionRetryWaitTime: connectionRetryWaitTime,
    autoResyncRetries: autoResyncRetries, chunkSize: chunkSize,
    verbose: verbose)
end
request(action, url, body: {}, headers: {}, query: {}, key: nil, return_direct_result: false, skip_to_json: false, keepNull: false) click to toggle source

REQUEST ===

# File lib/Database.rb, line 59
def request(action, url, body: {}, headers: {},
  query: {}, key: nil, return_direct_result: false,
  skip_to_json: false, keepNull: false)
  url = "_db/#{@name}/#{url}"
  @server.request(action, url, body: body,
    headers: headers, query: query, key: key,
    return_direct_result: return_direct_result,
    skip_to_json: skip_to_json, keepNull: keepNull)
end
retrieve() click to toggle source
# File lib/Database.rb, line 83
def retrieve
  result = request("GET", "_api/database/current", key: :result)
  assign_attributes(result)
  return return_directly?(result) ? result : self
end
Also aliased as: current
retrieveQueryCache() click to toggle source
# File lib/Database.rb, line 182
def retrieveQueryCache
  request("GET", "_api/query-cache/entries")
end
revokeUserAccess(user:) click to toggle source
# File lib/Database.rb, line 365
def revokeUserAccess(user:)
  user = check_user(user)
  user.revokeDatabaseAccess(database: @name)
end
serverId() click to toggle source
# File lib/Database.rb, line 270
def serverId
  request("GET", "_api/replication/server-id", key: :serverId)
end
slowQueries() click to toggle source
# File lib/Database.rb, line 166
def slowQueries
  request("GET", "_api/query/slow")
end
stopSlowQueries() click to toggle source
# File lib/Database.rb, line 170
def stopSlowQueries
  result = request("DELETE", "_api/query/slow")
  return return_delete(result)
end
tail(from: nil, to: nil, global: nil, chunkSize: nil, serverID: nil, barrierID: nil) click to toggle source
# File lib/Database.rb, line 282
def tail(from: nil, to: nil, global: nil, chunkSize: nil,
  serverID: nil, barrierID: nil)
  query = {
    from: from,
    to: to,
    global: global,
    chunkSize: chunkSize,
    serverID: serverID,
    barrierID: barrierID
  }
  request("GET", "_api/wal/tail", query: query)
end
task(id: nil, name: nil, type: nil, period: nil, command: nil, params: nil, created: nil, body: {}) click to toggle source

TASK ===

# File lib/Database.rb, line 391
def task(id: nil, name: nil, type: nil, period: nil, command: nil, params: nil, created: nil, body: {})
  Arango::Task.new(id: id, name: name, type: type, period: period, command: command,
    params: params, created: created, body: body, database: self)
end
tasks() click to toggle source
# File lib/Database.rb, line 396
def tasks
  result = request("GET", "_api/tasks")
  return result if return_directly?(result)
  result.delete_if{|k| k[:database] != @name}
  result.map do |task|
    Arango::Task.new(body: task, database: self)
  end
end
to_h() click to toggle source

TO HASH ===

# File lib/Database.rb, line 46
def to_h
  {
    "name":     @name,
    "isSystem": @isSystem,
    "path":     @path,
    "id":       @id,
    "cache_name": @cache_name,
    "server": @server.base_uri
  }.delete_if{|k,v| v.nil?}
end
transaction(action:, write: [], read: [], params: nil, maxTransactionSize: nil, lockTimeout: nil, waitForSync: nil, intermediateCommitCount: nil, intermedateCommitSize: nil) click to toggle source

TRANSACTION ===

# File lib/Database.rb, line 407
def transaction(action:, write: [], read: [], params: nil,
  maxTransactionSize: nil, lockTimeout: nil, waitForSync: nil,
  intermediateCommitCount: nil, intermedateCommitSize: nil)
  Arango::Transaction.new(database: self, action: action, write: write,
    read: read, params: params, maxTransactionSize: maxTransactionSize,
    lockTimeout: lockTimeout, waitForSync: waitForSync,
    intermediateCommitCount: intermediateCommitCount,
    intermedateCommitSize: intermedateCommitSize)
end
userAccess(user:) click to toggle source
# File lib/Database.rb, line 370
def userAccess(user:)
  user = check_user(user)
  user.databaseAccess(database: @name)
end
view(name:) click to toggle source
# File lib/Database.rb, line 385
def view(name:)
  Arango::View.new(database: self, name: name)
end
views() click to toggle source

VIEW ===

# File lib/Database.rb, line 377
def views
  result = request("GET", "_api/view", key: :result)
  return result if return_directly?(result)
  result.map do |view|
    Arango::View.new(database: self, id: view[:id], name: view[:name], type: view[:type])
  end
end

Private Instance Methods

check_user(user) click to toggle source

USER ACCESS ===

# File lib/Database.rb, line 354
def check_user(user)
  user = Arango::User.new(user: user) if user.is_a?(String)
  return user
end