Module: RestOperations

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

Instance Method Summary collapse

Instance Method Details

#call_function(*args) ⇒ Object

untested



6
7
8
9
10
11
12
13
14
 
# File 'lib/rest/operations.rb', line 6

def call_function *args  
#     puts "uri:#{function_uri { args.join('/') } }"
  begin
    term = args.join('/')
    @res["/function/#{@database}/#{term}"].post ''
  rescue RestClient::InternalServerError => e
    puts  JSON.parse(e.http_body)
  end
end

#count(**args) ⇒ Object

Used to count the Records in relation of the arguments

Overwritten by Model#Count



19
20
21
22
23
24
25
 
# File 'lib/rest/operations.rb', line 19

def count **args
  logger.progname = 'RestOperations#CountRecords'
  query = OrientSupport::OrientQuery.new args
  query.projection << 'COUNT (*)'
  result = get_records raw: true, query: query
  result.first['COUNT'] rescue  0  # return_value
end

#execute(transaction: true, tolerated_error_code: nil, process_error: true, raw: nil) ⇒ Object

Executes a list of commands and returns the result-array (if present)

(External use)

If soley a string is provided in the block, a minimal database-console is realized. i.e.

ORD.execute{ 'select from #25:0' }

(Internal Use)

Structure of the provided block:

[{type: "cmd", language: "sql",  command: "create class Person extends V"}, (...)]

–

It was first used by ActiveOrient::Query.execute_queries
Later I (topofocus) discovered that some Queries are not interpretated correctly by #GetRecords but are submitted without Error via batch-processing.
For instance, this valid query
 select expand(first_list[5].second_list[9]) from base where label = 9
can only be submitted via batch

++ Parameters:

transaction:  true|false   Perform the batch as transaction
tolerate_error_code: /a regular expression/   
Statements to execute are provided via block
These statements are translated to json and transmitted to the database. Example:

    { type: "cmd",
         language: 'sql',
         command: "CREATE EDGE #{classname(o_class)} FROM #{from.to_orient} TO #{to.to_orient}"}

Multible statements are transmitted at once if the Block provides an Array of statements.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
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
 
# File 'lib/rest/operations.rb', line 96

def execute transaction: true, tolerated_error_code: nil, process_error: true, raw: nil # Set up for classes
  batch = {transaction: transaction, operations: yield}
  logger.progname= "Execute"
#    puts "batch: #{batch[:operations]}"
  unless batch[:operations].blank?
    batch[:operations] = {:type=>"cmd", :language=>"sql", :command=> batch[:operations]} if batch[:operations].is_a? String
    batch[:operations] = [batch[:operations]] unless batch[:operations].is_a? Array
    batch[:operations].compact!
    # transaction is true only for multible statements
#      batch[:transaction] = transaction & batch[:operations].size >1
    begin
  logger.debug{ batch[:operations].map{|y|y[:command]}.join("; ") } 
      response = @res["/batch/#{ActiveOrient.database}"].post batch.to_json
    rescue RestClient::BadRequest => f
  # extract the misspelled query in logfile and abort
  sentence=  JSON.parse( f.response)['errors'].last['content']
  logger.fatal{ " BadRequest --> #{sentence.split("\n")[1]} " }
  puts "Query not recognized"
  puts sentence
  raise
    rescue RestClient::InternalServerError => e
      logger.progname = 'RestOperations#Execute'
  sentence=  JSON.parse( e.response)['errors'].last['content']
  if tolerated_error_code.present? &&  e.response =~ tolerated_error_code
 logger.info{ "tolerated_error::#{e.message}"}
  else
 if process_error
#     puts batch.to_json
#   logger.error{e.response}
 logger.error{sentence}
 logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
#   logger.error{e.message.to_s}
 else 
   raise
 end
  end 
    rescue Errno::EADDRNOTAVAIL => e
  sleep(2)
  retry
    end
    if response.present? && response.code == 200
      if response.body['result'].present?
        result=JSON.parse(response.body)['result']
 return result if raw.present?
        result.map do |x|
          if x.is_a? Hash
            if x.has_key?('@class')
              ActiveOrient::Model.orientdb_class(name: x['@class'], superclass: :find_ME ).new x
            elsif x.has_key?('value')
              x['value']
            else   # create a dummy class and fill with attributes from result-set
              ActiveOrient::Model.orientdb_class(name: 'query' ).new x
            end
          end
        end.compact # return_value
      else
        response.body
      end
    else
      nil
    end
  end
end