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){{


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