Module: RestRead

Included in:
ActiveOrient::OrientDB
Defined in:
lib/rest/read.rb

Instance Method Summary collapse

Instance Method Details

#get_class_properties(o_class) ⇒ Object

Returns a JSON of the property of a class

ORD.create_vertex_class a:
ORD.get_class_properties A
 => {"name"=>"a", "superClass"=>"V", "superClasses"=>["V"], "alias"=>nil, "abstract"=>false, "strictmode"=>false, "clusters"=>[65, 66, 67, 68], "defaultCluster"=>65, "clusterSelection"=>"round-robin", "records"=>3}



50
51
52
53
54
55
 
# File 'lib/rest/read.rb', line 50

def get_class_properties o_class
  JSON.parse(@res["/class/#{ActiveOrient.database}/#{classname(o_class)}"].get)
rescue => e
  logger.error  e.message
  nil
end

#get_classes(*attributes) ⇒ Object

Returns an Array with (unmodified) Class-attribute-hash-Elements

»get_classes ‘name’, ‘superClass’« returns

[ {"name"=>"E", "superClass"=>""},
{"name"=>"OFunction", "superClass"=>""},
{"name"=>"ORole", "superClass"=>"OIdentity"}
(...)    ]



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/rest/read.rb', line 22

def get_classes *attributes
  begin
    response = @res["/database/#{ActiveOrient.database}"].get
    if response.code == 200
      classes = JSON.parse(response.body)['classes']
      unless attributes.empty?
        classes.map{|y| y.select{|v,_| attributes.include?(v)}}
      else
        classes
      end
    else
      []
    end
  rescue Exception => e
    logger.progname = 'RestRead#GetClasses'
    logger.error{e.message}
  end
end

#get_databases ⇒ Object

Returns an Array with available Database-Names as Elements

ORD.get_databases
 => ["temp", "GratefulDeadConcerts", (...)]



9
10
11
 
# File 'lib/rest/read.rb', line 9

def get_databases
  JSON.parse(@res["/listDatabases"].get.body)['databases']
end

#get_record(rid) ⇒ Object Also known as: get_document

Retrieves a Record from the Database

The argument can either be a rid “#x:y” or a link “x:y”.

(to be specific: it must provide the methods rid? and to_orient, the latter must return the rid: “#[a}:b”.)

If no Record is found, nil is returned

The rid-cache is not used or updated



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/rest/read.rb', line 85

def get_record rid
  begin
    logger.progname = 'RestRead#GetRecord'
    if rid.rid?
      response = @res["/document/#{ActiveOrient.database}/#{rid.to_orient[1..-1]}"].get
      raw_data = JSON.parse(response.body) 
      #  ActiveOrient::Model.use_or_allocate( raw_data['@rid'] ) do 
      the_object=   ActiveOrient::Model.orientdb_class(name: raw_data['@class']).new raw_data
      ActiveOrient::Base.store_rid( the_object )   # update cache
    else
      logger.error { "Wrong parameter #{rid.inspect}. " }
      nil
    end
  rescue RestClient::InternalServerError => e
    if e.http_body.split(':').last =~ /was not found|does not exist in database/
      nil
    else
      logger.error { "Something went wrong" }
      logger.error { e.http_body.inspect }
      raise
    end
  rescue RestClient::ResourceNotFound => e
    logger.error { "RID: #{rid} ---> No Record present " }
    ActiveOrient::Model.remove_rid rid      #  remove rid from cache
    nil
  rescue Exception => e
    logger.error { "Something went wrong" }
    logger.error { "RID: #{rid} - #{e.message}" }
    raise
  end
end

#get_records(raw: false, query: nil, **args) ⇒ Object Also known as: get_documents

Retrieves Records from a query

If raw is specified, the JSON-Array is returned, e.g.

{"@type"=>"d", "@rid"=>"#15:1", "@version"=>1,    "@class"=>"DocumebntKlasse10", "con_id"=>343, "symbol"=>"EWTZ"}

Otherwise ActiveModel-Instances are created and returned. In this case cached data are used in favour and its not checked if the database contents have changed.



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/rest/read.rb', line 128

def get_records raw: false, query: nil, **args
  query = OrientSupport::OrientQuery.new(args) if query.nil?
  begin
    logger.progname = 'RestRead#GetRecords'
    url = "/query/#{ActiveOrient.database}/sql/" + query.compose(destination: :rest) + "/#{query.get_limit}"
    response = @res[URI.encode(url)].get
 JSON.parse(response.body)['result'].map do |record|
   if raw
     record
     # query returns an anonymus class: Use the provided Block or the Dummy-Model MyQuery
   elsif record['@class'].blank?
     block_given? ? yield.new(record) : ActiveOrient::Model.orientdb_class(name: 'query' ).new( record )
   else
the_object = ActiveOrient::Model.orientdb_class(name: record['@class']).new record
ActiveOrient::Base.store_rid( the_object )   # update cache
#       end
   end
 end
 # returns an array of updated objects
   
  rescue RestClient::BadRequest  => e
    #puts e.inspect
 logger.error { "-"*30 }
 logger.error { "REST_READ#GET_RECORDS.URL ---> Wrong Query" }
 logger.error {  query.compose( destination: :rest).to_s }
 logger.error { "Fired Statement: #{url.to_s} " }
  response=""
  rescue RestClient::InternalServerError => e
    response = JSON.parse(e.response)['errors'].pop
 logger.error{ "Interbak Server ERROR" }
    logger.error{response['content'].split(':').last}
  rescue URI::InvalidURIError => e
    logger.error{"Invalid URI detected"}
    logger.error query.to_s
    logger.info{"Trying batch processing"}
    sql_cmd = -> (command){{type: "cmd", language: "sql", command: command}}
    response = execute{[sql_cmd[query.to_s]]}
    logger.info{"Success: to avoid this delay use ActiveOrient::Model#query_database instead"}
    response
  end
end

#print_class_properties(o_class) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/rest/read.rb', line 58

def print_class_properties o_class
  puts "Detected Properties for class #{classname(o_class)}"
  rp = get_class_properties o_class
  n = rp['name']
  if rp['properties'].nil?
    puts "No property available"
  else
    puts rp['properties'].map{|x| "\t"+[n+'.'+x['name'], x['type'],x['linkedClass']].compact.join("\t-> ")}.join("\n")
  end
rescue NoMethodError
  puts "Class #{o_class} not present in database"
end