Module: RestCreate

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

Instance Method Summary collapse

Instance Method Details

#create_database(type: 'plocal', database:) ⇒ Object

Creates a database with the given name and switches to this database as working-database. Types are either 'plocal' or 'memory'

Returns the name of the working-database

11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# File 'lib/rest/create.rb', line 11

def create_database type: 'plocal', database: 
	logger.progname = 'RestCreate#CreateDatabase'
	old_d = ActiveOrient.database
	ActiveOrient.database_classes = {} 
	ActiveOrient.database = database 
	begin
		response = @res["database/#{ActiveOrient.database}/#{type}"].post ""
		if response.code == 200
			logger.info{"Database #{ActiveOrient.database} successfully created and stored as working database"}
		else
			logger.error{"Database #{ActiveOrient.database} was NOT created. Working Database is still #{ActiveOrient.database}"}
			ActiveOrient.database = old_d
		end
	rescue RestClient::InternalServerError => e
		logger.error{"Database #{ActiveOrient.database} was NOT created. Working Database is still #{ActiveOrient.database}"}
		ActiveOrient.database = old_d
	end
	ActiveOrient.database  # return_value
end

#create_index(o_class, name:, on: :automatic, type: :unique) ⇒ Object

Used to create an index


260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
# File 'lib/rest/create.rb', line 260

def create_index o_class, name:, on: :automatic, type: :unique
   logger.progname = 'RestCreate#CreateIndex'
     c = classname o_class
		if  execute( transaction: false, tolerated_error_code: /found duplicated key/) do
			if on == :automatic
				"CREATE INDEX #{c}.#{name} #{type.to_s.upcase}"
			elsif on.is_a? Array
				"CREATE INDEX #{name} ON #{c}(#{on.join(', ')}) #{type.to_s.upcase}"
			else
				"CREATE INDEX #{name} ON #{c}(#{on.to_s}) #{type.to_s.upcase}"
			end
		end

		logger.info{"Index on #{c} based on #{name} created."}
		else
			logger.error {"index #{name}.#{type} on  #{c}  NOT created"}
		end
end

#create_properties(o_class, all_properties, &b) ⇒ Object

Creates properties

and (if defined in the provided block) associates an index

create_properties(classname or class, properties as hash){index}

The default-case

  create_properties(:my_high_sophisticated_database_class,
		con_id: {type: :integer},
		details: {type: :link, linked_class: 'Contracts'}) do
		  contract_idx: :notunique
		end

A composite index

  create_properties(:my_high_sophisticated_database_class,
		con_id: {type: :integer},
		symbol: {type: :string}) do
	    {name: 'indexname',
			 on: [:con_id, :details]    # default: all specified properties
			 type: :notunique            # default: :unique
	    }
		end

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
222
223
# File 'lib/rest/create.rb', line 189

def create_properties o_class, all_properties, &b
	logger.progname = 'RestCreate#CreateProperties'
	all_properties_in_a_hash = Hash.new  #WithIndifferentAccess.new
	all_properties.each{|field, args| all_properties_in_a_hash.merge! translate_property_hash(field, args)}
	count=0
#		puts "all_properties_in_a_hash #{all_properties_in_a_hash.to_json}"
	begin
		if all_properties_in_a_hash.is_a?(Hash)
			response = @res["/property/#{ActiveOrient.database}/#{classname(o_class)}"].post all_properties_in_a_hash.to_json
#				puts response.inspect
			# response.body.to_i returns  response.code, only to_f.to_i returns the correct value
			count= response.body.to_f.to_i if response.code == 201
		end
	rescue RestClient::InternalServerError => e
		logger.progname = 'RestCreate#CreateProperties'
		response = JSON.parse(e.response)['errors'].pop
		error_message = response['content'].split(':').last
		logger.error{"Properties in #{classname(o_class)} were NOT created"}
		logger.error{"The Error was: #{response['content'].split(':').last}"}
		nil
	end
	### index
	if block_given?# && count == all_properties_in_a_hash.size
		index = yield
		if index.is_a?(Hash)
			if index.size == 1
				create_index o_class, name: index.keys.first, on: all_properties_in_a_hash.keys, type: index.values.first
			else
				index_hash =  {type: :unique, on: all_properties_in_a_hash.keys}.merge index
				create_index o_class,  name: index_hash[:name], on: index_hash[:on], type: index_hash[:type]
			end
		end
	end
	count  # return_value
end

#create_property(o_class, field, index: nil, **args, &b) ⇒ Object

Create a single property.

Supported types: orientdb.com/docs/last/SQL-Create-Property.html

If an index is to be specified, it's defined in the optional block

create_property(class, field){:unique | :notunique}	                    
--> creates an automatic-Index on the given field

create_property(class, field){{»name« => :unique | :notunique | :full_text}} 
--> creates a manual index

239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
# File 'lib/rest/create.rb', line 239

def create_property o_class, field, index: nil, **args, &b
  logger.progname = 'RestCreate#CreateProperty'
  args= { type: :string} if args.blank?  # the default case
  c = create_properties o_class, {field => args}
  if index.nil? && block_given?
    index = yield
  end
  if index.present?
    if index.is_a?(String) || index.is_a?(Symbol)
	create_index o_class, name: field, type: index
    elsif index.is_a? Hash
	bez = index.keys.first
	create_index o_class, name: bez, type: index[bez], on: [field]
    end
  end
end

#create_record(o_class, attributes: {}, cache: true) ⇒ Object Also known as: create_document

Creates a Record in the Database and returns this as ActiveOrient::Model-Instance

Creates a Record with the attributes provided in the attributes-hash e.g.

create_record @classname, attributes: {con_id: 343, symbol: 'EWTZ'}

Puts the database-response into the cache by default


94
95
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
# File 'lib/rest/create.rb', line 94

def create_record o_class, attributes: {}, cache: true    # use Model#create instead
  logger.progname = 'RestCreate#CreateRecord'
  attributes = yield if attributes.empty? && block_given?
  # @class must not quoted! Quote only attributes(strings)
  post_argument = {'@class' => classname(o_class)}.merge(attributes.to_orient)
  begin
    response = @res["/document/#{ActiveOrient.database}"].post post_argument.to_json
    data = JSON.parse(response.body)
    the_object = ActiveOrient::Model.orientdb_class(name: data['@class']).new data ## return_value
    if cache 
 ActiveOrient::Base.store_rid( the_object ) 
    else
	the_object
    end
  rescue RestClient::InternalServerError => e
    sentence=  JSON.parse( e.response)['errors'].last['content']
#      puts sentence.to_s
    if sentence =~ /found duplicated key/
	rid = sentence.split("#").last
	logger.info{ "found duplicated Key --> loaded #{rid} instead of creating "}
	## reading database content -- maybe update attributes?
	get_record rid
    else
	response = JSON.parse(e.response)['errors'].pop
	logger.error{response['content'].split(':')[1..-1].join(':')}
	logger.error{"No Object allocated"}
	nil # return_value
     end
  rescue Errno::EADDRNOTAVAIL => e
    sleep(2)
    retry
  end
end

#upsert(o_class, set:, where:) ⇒ Object

update or insert one record is implemented as upsert. The where-condition is merged into the set-attributes if its a hash.

Otherwise it's taken unmodified.

The method returns the included or the updated dataset

## to do # yield works for updated and for inserted datasets # upsert ( ) do | what, record | # if what == :insert # do stuff with insert # if what == :update # do stuff with update # end # returns nil if no insert and no update was made, ie. the dataset is identical to the given attributes


154
155
156
157
158
159
160
161
162
# File 'lib/rest/create.rb', line 154

def upsert o_class, set: , where:    #    use Model#Upsert instead
	logger.progname = 'RestCreate#Upsert'
	specify_return_value =  "return after @rid"
	#			set.merge! where if where.is_a?( Hash ) # copy where attributes to set 
	command = "Update #{classname(o_class)} set #{generate_sql_list( set ){','}} upsert #{specify_return_value}  #{compose_where where}" 
	result = execute( tolerated_error_code: /found duplicated key/){ command }	
#	puts "result #{result.inspect}"
	result =result.pop if result.is_a? Array
end