Module: RestOperations

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

Instance Method Summary collapse

Instance Method Details

#_execute(transaction, tolerated_error_code, process_error, raw) ⇒ Object


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

def _execute transaction, tolerated_error_code, process_error, raw

	logger.progname= "Execute"
	begin
		response = if @transaction.is_a?(Array) 
								 @transaction.compact!
								 return nil if @transaction.empty?
								 # 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
							 else
								 logger.info{ @transaction } 
								 @res["/command/#{ActiveOrient.database}/sql"].post @transaction #.to_json
							 end
	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
		@transaction = []
		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
				#	    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
	else  # code to execute if no exception  is raised
		@transaction = []
		if response.code == 200
			if response.body['result'].present?
				result=JSON.parse(response.body)['result']
				if raw.present? 
					 result
				else
					y= result.from_orient
				end
			else
				response.body
			end
		else
			nil
		end
	end
end

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


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

def execute transaction: false, tolerated_error_code: nil, process_error: true, raw: nil
	@transaction = []  unless @transaction.is_a?(Array)
	if block_given?
		command =  yield
		command.is_a?(Array) ? command.each{|c| @transaction << c} : @transaction << command
	else
		logger.error { "No Block provided to execute" }
		return nil
	end

#			puts "transaction #{@transaction.inspect}"
	unless transaction == :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}"
		return nil if commands.empty?
		if commands.size >1
		@transaction <<	{ type: 'script', language: 'sql', script: commands } 
		elsif  transaction ==  false
			@transaction = 	commands.first
		else
			transaction =  true
			@transaction <<		{ type: 'cmd', language: 'sql', command: commands.first } 
		end	
			_execute transaction, tolerated_error_code, process_error, raw
	end
end

#read_transactionObject

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.


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

def read_transaction
	@transaction
end