Module: RestCreate

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

Instance Method Summary collapse

Instance Method Details

#create_classes(*classes, &b) ⇒ Object

General method to create database classes

Accepts

  • a string or symbol

    creates a single class and returns the ActiveOrient::Model-Class

  • an arrray of strings or symbols

    creates alltogether and returns an array of created ActiveOrient::Model-Classes

  • a (nested) Hash

    then creates a hierarchy of database-classes and returns them as hash

takes an optional block to specify a superclass. This class MUST exist.

eg.

create_classes( :test ){ :V }

creates a vertex-class, returns just Test ( < ActiveOrient::Model)

a,b,c = create_classes( :test1, :test2, test3 ) { :V }

creates three vertex-classes and assigns them to var’s a,b, and c

create_classes( test: [:test1, :test2, test3] ) { :V }

creates a vertex-class Test and three clild-classes

create_classes( :V => :test)

creates a vertex-class, too, returns the Hash

#todo #check if a similar classname already exists –> Contract == contract == conTract #and assign to this existing one.



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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/rest/create.rb', line 88

def create_classes *classes, &b
  returt if classes.empty?

  classes =  classes.pop if classes.size == 1
  consts = allocate_classes_in_ruby( classes , &b )
  all_classes = consts.is_a?( Array) ? consts.flatten : [consts]
  dc = database_classes(requery: true)
  selected_classes =  all_classes.map do | this_class |
    this_class unless dc.include?( this_class.ref_name ) rescue nil
  end.compact.uniq

  command= selected_classes.map do | database_class |
    ## improper initialized ActiveOrient::Model-classes lack a ref_name class-variable
    if database_class.ref_name.blank?  
  logger.error{ "Improper initialized ActiveOrient::Model #{database_class}" }
  raise ArgumentError
    end 
    database_class.require_model_file
    c = if database_class.superclass == ActiveOrient::Model || database_class.superclass.ref_name.blank?
   "CREATE CLASS #{database_class.ref_name}" 
 else
   "CREATE CLASS #{database_class.ref_name} EXTENDS #{database_class.superclass.ref_name}"
 end
    c << " ABSTRACT" if database_class.abstract
    { type: "cmd", language: 'sql', command: c }  # return value 4 command
  end
  # execute anything as batch, don't roll back in case of an error

  execute transaction: false, tolerated_error_code: /already exists in current database/ do
    command
  end
  # update the internal class hierarchy 
  database_classes requery: true
  # return all allocated classes, no matter whether they had to be created in the DB or not.
  #  keep the format of the input-parameter
  #consts.shift if block_given? && consts.is_a?( Array) # remove the first element
  # remove traces of superclass-allocations
  if classes.is_a? Hash
    consts =  Hash[ consts ] 
    consts.each_key{ |x| consts[x].delete_if{|y| y == x} if consts[x].is_a? Array  }
  end
  consts

rescue ArgumentError => e
  logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
end

#create_database(type: 'plocal', database: nil) ⇒ 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: nil
  logger.progname = 'RestCreate#CreateDatabase'
  old_d = ActiveOrient.database
  ActiveOrient.database_classes = []
  ActiveOrient.database = database if database.present?
  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
      ActiveOrient.database = old_d
      logger.error{"Database #{name} was NOT created. Working Database is still #{ActiveOrient.database}"}
    end
  rescue RestClient::InternalServerError => e
    ActiveOrient.database = old_d
    logger.error{"Database #{name} was NOT created. Working Database is still #{ActiveOrient.database}"}
  end
  ActiveOrient.database
end

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

Used to create an index



447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
 
# File 'lib/rest/create.rb', line 447

def create_index o_class, name:, on: :automatic, type: :unique
  logger.progname = 'RestCreate#CreateIndex'
  begin
    c = classname o_class
    puts "CREATE INDEX: class: #{c.inspect}"
    execute transaction: false do
      command = 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}"
        #nil
      end
 #puts "command: #{command}"
      {type: "cmd", language: 'sql', command: command} if command.present?
    end
    logger.info{"Index on #{c} based on #{name} created."}
  rescue RestClient::InternalServerError => e
    response = JSON.parse(e.response)['errors'].pop
    error_message = response['content'].split(':').last
    logger.error{"Index not created."}
    logger.error{"Error-code #{response['code']} --> #{response['content'].split(':').last }"}
    nil
  end
end

#create_multiple_records(o_class, values, new_records) ⇒ Object

Used to create multiple records at once

For example:
  $r.create_multiple_records "Month", ["date", "value"], [["June", 6], ["July", 7], ["August", 8]]
It is equivalent to this three functios:
  $r.create_record "Month", attributes: {date: "June", value: 6}
  $r.create_record "Month", attributes: {date: "July", value: 7}
  $r.create_record "Month", attributes: {date: "August", value: 8}

The function $r.create_multiple_records "Month", ["date", "value"], [["June", 6], ["July", 7], ["August", 8]] will return an array with three element of class "Active::Model::Month".



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/rest/create.rb', line 250

def create_multiple_records o_class, values, new_records  # :nodoc:  # untested
  command = "INSERT INTO #{o_class} ("
  values.each do |val|
    command += "#{val},"
  end
  command[-1] = ")"
  command += " VALUES "
  new_records.each do |new_record|
    command += "("
    new_record.each do |record_value|
      case record_value
      when String
        command += "\'#{record_value}\',"
      when Integer
        command += "#{record_value},"
      when ActiveOrient::Model
        command += "##{record_value.rid},"
      when Array
        if record_value[0].is_a? ActiveOrient::Model
          command += "["
          record_value.rid.each do |rid|
            command += "##{rid},"
          end
          command[-1] = "]"
          command += ","
        else
          command += "null,"
        end
      else
        command += "null,"
      end
    end
    command[-1] = ")"
    command += ","
  end
  command[-1] = ""
  execute  transaction: false do # To execute commands
    [{ type: "cmd",
      language: 'sql',
      command: command}]
  end
end

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

Creates properties and optional an associated index as defined in the provided block

  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



382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
 
# File 'lib/rest/create.rb', line 382

def create_properties o_class, all_properties, &b
  logger.progname = 'RestCreate#CreateProperties'
  all_properties_in_a_hash = HashWithIndifferentAccess.new
  all_properties.each{|field, args| all_properties_in_a_hash.merge! translate_property_hash(field, args)}
  count=0
  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
  # response.body.to_i returns  response.code, only to_f.to_i returns the correrect 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)
 puts "index_class: #{o_class}"
 puts "index: "+index.inspect
  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 =  HashWithIndifferentAccess.new(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 on class-level.

Supported types: https://orientdb.com/docs/last/SQL-Create-Property.html
If 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



426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
 
# File 'lib/rest/create.rb', line 426

def create_property o_class, field, index: nil, **args, &b
  logger.progname = 'RestCreate#CreateProperty'
  args= { type: :integer} 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: {}) ⇒ Object Also known as: create_document

Creates a Record (NOT edge) 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'}

untested: for hybrid and schema-less documents the following syntax is supported
 create_document , attributes: {date: 1350426789, amount: 100.34,           "@fieldTypes" => "date = t, amount = c"}

The supported special types are:
 'f' for float
 'c' for decimal
 'l' for long
 'd' for double
 'b' for byte and binary
 'a' for date
 't' for datetime
 's' for short
 'e' for Set, because arrays and List are serialized as arrays like [3,4,5]
 'x' for links
 'n' for linksets
 'z' for linklist
 'm' for linkmap
 'g' for linkbag



216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/rest/create.rb', line 216

def create_record o_class, attributes: {}  # :nodoc:  # 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)
    if o_class.is_a?(Class) && o_class.new.is_a?(ActiveOrient::Model)
    o_class.new data
    else
    ActiveOrient::Model.orientdb_class(name: data['@class'], superclass: :find_ME).new data
    end
  rescue RestClient::InternalServerError => e
    response = JSON.parse(e.response)['errors'].pop
    logger.error{response['content'].split(':')[1..-1].join(':')}
    logger.error{"No Object allocated"}
    nil # return_value
  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



316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
 
# File 'lib/rest/create.rb', line 316

def upsert o_class, set: {}, where: {}   # :nodoc:   use Model#Upsert instead
  logger.progname = 'RestCreate#Upsert'
  if where.blank?
    new_record = create_record(o_class, attributes: set)
    yield new_record if block_given?    # in case if insert execute optional block
    new_record        # return_value
  else
    specify_return_value =  block_given? ? "" : "return after @this"
    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}" 


    #  puts "COMMAND: #{command} "
    result = execute  tolerated_error_code: /found duplicated key/, raw: true do # To execute commands
  [ { type: "cmd", language: 'sql', command: command}]
    end 
    result =result.pop if result.is_a? Array
  #  puts "RESULT: #{result.inspect}, #{result.class}"
  if result.has_key?('@class')
 if o_class.is_a?(Class) && o_class.new.is_a?(ActiveOrient::Model)
   o_class.new result
 else
   AddctiveOrient::Model.orientdb_class(name: data['@class'], superclass: :find_ME).new data
 end
  elsif result.has_key?('value')
 the_record=  get_records(from: o_class, where: where, limit: 1).pop
 ## process Code if a new dataset is inserted
 if  result['value'].to_i == 1
   yield the_record   if block_given?
   logger.info{ "Dataset updated" }
 elsif result['value'].to_i == 0
   logger.info{ "Dataset inserted"}
 end
 the_record  # return_value

  else
 logger.error{ "Unexpected result form Query \n  #{command} \n Result: #{result}" }
 raise ArgumentError
  end

    end
end