Module: RestOperations

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

Instance Method Summary collapse

Instance Method Details

#_execute(tolerated_error_code, process_error, raw) ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/rest/operations.rb', line 172

def _execute tolerated_error_code, process_error, raw

	logger.progname= "Execute"

	begin
		response = yield
	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::Conflict => e  # (409)
		# most probably the server is busy. we  wait for a second  print an Error-Message and retry
		sleep(1)
		logger.error{ e.inspect }
		logger.error{ "RestClient::Error(409): Server is signaling a conflict ... retrying" }
		retry
	rescue RestClient::InternalServerError => e
		sentence=  JSON.parse( e.response)['errors'].last['content']
		if tolerated_error_code.present? &&  e.response =~ tolerated_error_code
			logger.debug('RestOperations#Execute'){ "tolerated_error::#{e.message}"}
			logger.debug('RestOperations#Execute'){ e.message }
			nil  # return value
		else
			if process_error
				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
	else  # code to execute if no exception  is raised
		if response.code == 200
			result=JSON.parse(response.body)['result']
			if raw.present? 
				result
			else
				result.from_orient
			end # raw present?
		else
			logger.error { "code : #{response.code}" }
		end
	end
end

#call_function(*args) ⇒ Object

untested



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

def call_function *args  
#     puts "uri:#{function_uri { args.join('/') } }"
  begin
    term = args.join('/')
rest_resource = Thread.current['resource'] || get_resource 
   rest_resource["/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



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

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: nil, command: nil, tolerated_error_code: nil, process_error: true, raw: nil) ⇒ Object

execute the command

thread-safe ( transaction = false)



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
169
 
# File 'lib/rest/operations.rb', line 141

def execute transaction: nil,
	          command: nil,
						tolerated_error_code: nil, 
						process_error: true, 
						raw: nil 
	
	if block_given?
		command =  yield
	end
  unless command.present?	
		logger.error { "No Command  provided to execute" }
		return nil
	end
	if ( transaction.present? || command.is_a?(Array) )
		logger.error  "calling manage_transaction NOT IMPLEMENTED YET!"
		manage_transaction transaction, command
	end		

	 logger.info command.to_s								
	_execute( tolerated_error_code, process_error, raw) do

		ActiveOrient.db_pool.checkout do | conn |
			conn["/command/#{ActiveOrient.database}/sql"].post command.to_s #.to_json
		end
	end

#		rest_resource.delete #if resource.present?

end

#manage_transaction(kind, command) ⇒ Object 



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
 
# File 'lib/rest/operations.rb', line 106

def manage_transaction kind, command
	@transaction = []  unless @transaction.is_a?(Array)

	# in any case:  add statement to array
	command.is_a?(Array) ? command.each{|c| @transaction << c} : @transaction << command

	# if kind is prepare, we a done. 
	# now, combine anything
	unless kind == :prepare
		commands =  @transaction.map{|y| y if y.is_a? String }.compact
		@transaction.delete_if{|y| y if y.is_a?(String)} 
		#puts "tn #{commands.inspect}"
			@transaction <<	{ type: 'script', language: 'sql', script: commands } unless  commands.empty?
#		elsif  transaction ==  false
#			@transaction = 	commands.first
#		else
#			transaction =  true
#			@transaction <<		{ type: 'cmd', language: 'sql', command: commands.first } 

			# transaction is true only for multible statements
			#      batch[:transaction] = transaction & batch[:operations].size >1
#			logger.info{ @transaction.map{|y|y[:command]}.join(";\n ") } 
#				logger.info{ @transaction.map{|y|y[:script]}.join(";\n ") } 
	#		batch= { transaction: transaction, operations: @transaction  }
	#		puts "batch:  #{batch.inspect}"

	#		@res["/batch/#{ActiveOrient.database}"].post batch.to_json
	end
end

#read_transaction ⇒ 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.



102
103
104
 
# File 'lib/rest/operations.rb', line 102

def read_transaction
	@transaction
end