class ActiveOrient::API

class Date

def proxy_object
  java.util.Date.new year, month - 1, day, 0, 0, 0 
end

end class DateTime

def proxy_object
  java.util.Date.new year, month - 1, day, hour, min, sec
end

end

Attributes

database[R]

Public Class Methods

new(database: nil, connect: true, preallocate: true) click to toggle source

INITIALIZATION ####

# File lib/java-api.rb, line 47
def initialize database: nil, connect: true, preallocate: true
  self.logger = Logger.new('/dev/stdout') unless logger.present?
  ActiveOrient.database= database if database.present?
  connect() if connect
  ActiveOrient::Model.db = self 
  preallocate_classes  if preallocate

end

Public Instance Methods

connect() click to toggle source

Used to connect to the database

# File lib/java-api.rb, line 65
    def connect
      begin
      logger.progname = 'JavaApi#connect'
      @db  =   DocumentDatabase.connect("remote:#{ActiveOrient.default_server[:server]}/#{ActiveOrient.database}",
                                        ActiveOrient.default_server[:user], ActiveOrient.default_server[:password] )
      rescue Java::ComOrientechnologiesOrientCoreException::OConfigurationException => e
          logger.fatal{ e.message}
          logger.fatal{ "ServerAdim not implemented in ActiveOrient#JavaApi "}
#         OrientDB::ServerAdmin("remote:localhost").connect( default_server[:user], default_server[:password] )
#         OrientDB::ServerAdmin.createDatabase(@database, "document", "remote");
#         OrientDB::ServerAdmin.close();
          Kernel.exit
      end
      database_classes( requery:true ) # returns all allocated database_classes
    end
create_classes(classes , &b) click to toggle source
# File lib/java-api.rb, line 94
def create_classes classes , &b
  consts = allocate_classes_in_ruby( classes , &b )

  all_classes = consts.is_a?( Array) ? consts.flatten : [consts]
  database_classes(requery: true)
  selected_classes =  all_classes.map do | this_class |
    this_class unless database_classes(requery: true).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
    next if database_class.ref_name.blank?  
    c = if database_class.superclass == ActiveOrient::Model || database_class.superclass.ref_name.blank?
          puts "CREATE CLASS #{database_class.ref_name} "
          OClassImpl.create @db, database_class.ref_name 
        else
          puts "CREATE CLASS #{database_class.ref_name} EXTENDS #{database_class.superclass.ref_name}"
          OClassImpl.create @db, database_class.ref_name, superClass: database_class.superclass.ref_name 
        end
  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
end
create_document(o_class, attributes: {})
Alias for: create_record
create_index(o_class, name:, on: :automatic, type: :unique) click to toggle source
# File lib/java-api.rb, line 217
def create_index o_class, name:, on: :automatic, type: :unique
  logger.progname = 'JavaApi#CreateIndex'
  begin
    c = @db.get_class( classname( o_class ))
    index = if on == :automatic
              nil   # not implemented
            elsif on.is_a? Array
              c.createIndex name.to_s, INDEX_TYPES[type],  *on
            else
              c.createIndex name.to_s, INDEX_TYPES[type],  on
            end
  end
end
create_properties(o_class, **all_properties) { || ... } click to toggle source
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

supported types: {

:bool          => "BOOLEAN",
:double        => "BYTE",
:datetime      => "DATE",
:float         => "FLOAT",
:decimal       => "DECIMAL",
:embedded_list => "EMBEDDEDLIST",
:list          => "EMBEDDEDLIST",
:embedded_map  => "EMBEDDEDMAP",
:map           => "EMBEDDEDMAP",
:embedded_set  => "EMBEDDEDSET",
:set           => "EMBEDDEDSET",
:int           => "INTEGER",
:integer       => "INTEGER",
:link_list     => "LINKLIST",
:link_map      => "LINKMAP",
:link_set      => "LINKSET",
}
# File lib/java-api.rb, line 179
def create_properties o_class, **all_properties, &b
  logger.progname = 'JavaApi#CreateProperties'
  ap =  all_properties
  index =  ap.is_a?(Hash) ?  ap[:index] : nil
  created_properties = ap.map do |property, specification | 
    field_type = ( specification.is_a?( Hash) ?  specification[:type] : specification ).downcase.to_sym rescue :string
    if  specification.is_a?(Hash) 
      the_other_class =  specification[:other_class].presence || specification[:linked_class] 
      other_class =        @db.get_class( the_other_class.to_sym ) if the_other_class.present?
      if other_class.present?
        @db.get_class(classname(o_class)).add property,[ field_type, other_class ], { :index => index }
      else
        @db.get_class(classname(o_class)).add property, field_type, { :index => index }
      end
    end
  end
  if block_given?
    attr =  yield
    index_parameters = case attr 
                       when String, Symbol
                         { name: attr }
                       when Hash
                         { name: attr.keys.first , type: attr.values.first, on: all_properties.keys.map(&:to_s) }
                       else
                         nil
                       end
    create_index o_class, **index_parameters unless index_parameters.blank?
  end
  created_properties.size # return_value

end
create_record(o_class, attributes: {}) { || ... } click to toggle source
# File lib/java-api.rb, line 230
def create_record o_class, attributes: {}
  logger.progname = 'JavaApi#CreateRecord'
  attributes = yield if attributes.empty? && block_given?
  new_record = insert_document( classname(o_class), attributes.to_orient )


end
Also aliased as: create_document, create_document
db() click to toggle source
# File lib/java-api.rb, line 56
def db
  @db
end
delete_class(o_class) click to toggle source
# File lib/java-api.rb, line 129
def delete_class o_class
  begin
  logger.progname = 'JavaApi#DeleteClass'
  @db.schema.drop_class classname(o_class)
  rescue Java::ComOrientechnologiesOrientCoreException::OSchemaException => e
    logger.error{ e.message }
  end
  database_classes requery: true 
end
delete_record(*object_or_rid) click to toggle source
# File lib/java-api.rb, line 351
def delete_record  *object_or_rid
  object_or_rid.map do |o|
    d= case o
       when  String 
         @db.custom "select from #{o}" if o.rid?
       when  ActiveOrient::Model
         @db.custom "select from #{o.to_orient}"
       when Array
         o.map{|y| delete_record y }
         return o
       else
         o
       end
    if d.is_a? Java::ComOrientechnologiesOrientCoreSqlQuery::OConcurrentResultSet
      d.each &:delete      
    else
      logger.progname = 'JavaApi#DeleteRecord'
      logger.error{ "Removal Failed: #{d.inspect} " }
    end
  end
end
execute(transaction: true, tolerated_error_code: nil , process_error: true batch = {transaction: transaction, operations: yield}) click to toggle source

executes a command as sql-query

# File lib/java-api.rb, line 296
    def execute transaction: true, tolerated_error_code: nil , process_error: true# Set up for classes
      batch = {transaction: transaction, operations: yield}

      logger.progname= "Execute"
      unless batch[:operations].blank?
        unless batch[:operations].is_a? Array
          batch[:operations] = [batch[:operations]]    
          was_array =  true
        else
          was_array =  false
        end
        answer = batch[:operations].map do |command_record|
          return if command_record.blank? 
          begin
          response = @db.run_command  command_record.is_a?(Hash) ?  command_record[:command] : command_record 
          rescue Java::ComOrientechnologiesOrientCoreStorage::ORecordDuplicatedException => e
#           puts e.inspect
#           puts "GetMESSAGE: "+e.getMessage.split(/\r/).first
#           puts "GetComponentName: "+e.getComponentName.to_s
#           puts  e.getMessage =~ tolerated_error_code
#           puts "----"
            if tolerated_error_code.present? &&  e.getMessage =~ tolerated_error_code
              logger.info{ "tolerated_error::#{ e.get_message.split(/\r/).first }"}
              next
            else
#           if process_error
              logger.progname = 'JavaApi#Execute'
              logger.error{ e }
#           else
#             puts e.inspect
#             raise ArgumentError, e, caller
            end
          end
          if response.is_a? Fixnum
            response
          else
            response.map do | r |
              if r.is_a? Document
                if r.rid.rid? 
                  update_document r 
                else
                  ActiveOrient::Model.orientdb_class( name: 'query').new  r
                end
              else 
                puts "Strange things happen in execute: #{r.inspect}"
                r.values
              end
            end  # map response
          end  #  branch response_is_a
        end    # map batch
        answer.pop if answer.size==1 && answer.first.is_a?(Array)
      end       # unless
    end
get_classes(*attributes) click to toggle source
# File lib/java-api.rb, line 83
def get_classes *attributes
  classes=  @db.metadata.schema.classes.map{|x| { 'name' => x.name , 'superClass' => x.get_super_class.nil? ? '': x.get_super_class.name } }
  unless attributes.empty?
    classes.map{|y| y.select{|v,_| attributes.include?(v)}}
  else
    classes
  end

end
get_document(rid)
Alias for: get_record
get_documents(raw: false, query: nil, **args)
Alias for: get_records
get_properties(o_class) click to toggle source
# File lib/java-api.rb, line 211
def get_properties o_class
  @db.get_class(classname(o_class)).propertiesMap
end
get_record(rid) { |record| ... } click to toggle source

called by Model.autoload

# File lib/java-api.rb, line 278
def get_record rid
  logger.progname = 'JavaApi#GetRecord'
  rid = "#"+ rid unless rid[0]=='#'
  record = @db.custom "select from #{rid}"
  if record.count.zero?
    logger.error{ "No record found for rid= #{rid}" }
  else
    yield( record[0] ) if block_given?
    update_document record[0]
  end
end
Also aliased as: get_document
get_records(raw: false, query: nil, **args) click to toggle source
# File lib/java-api.rb, line 267
def get_records raw: false, query: nil, **args
  query = OrientSupport::OrientQuery.new(args) if query.nil?
  logger.progname = 'JavaApi#GetRecords'
  result =  @db.custom query.compose
  result.map do |record|
    update_document record
  end
end
Also aliased as: get_documents
insert_document(o_class, attributes) click to toggle source

private

# File lib/java-api.rb, line 398
def insert_document o_class, attributes
  logger.progname = 'JavaApi#InsertDocument'
  d = Document.new  classname(o_class)
  d.update_attributes attributes
  d.save
  ActiveOrient::Model.get_model_class(o_class).new  d
rescue Java::ComOrientechnologiesOrientCoreException::ODatabaseException => e
  logger.fatal{ "Insert failed => #{d.inspect}"}
  logger.error{ "Parameter: Class: #{classname(o_class)} attributes: #{attributes.inspect}" }
  logger.fatal{ e }
rescue Java::ComOrientechnologiesOrientCoreException::OSchemaException => e
  logger.error{ e }

  logger.error{ "Parameter: DB: #{@db.name}, Class: #{classname(o_class)} attributes: #{attributes.inspect}" }
  logger.error{ database_classes.inspect }
end
manipulate_relation(record, method, array, items) click to toggle source
# File lib/java-api.rb, line 428
def manipulate_relation record,  method, array, items
  java_document = record.document
  method =  method.to_s.downcase.to_sym
  case method 
  when :add
    items.each{|x| java_document[array] << x}
  when :remove
    items.each{|x| java_document[array].delete x}
  else

  end
    java_document.save
end
update(rid, attributes=nil, version=nil) click to toggle source

Transfer changes in attributes to document first and save the document No SQL involved

# File lib/java-api.rb, line 378
def update rid, attributes=nil, version=nil
  record = ActiveOrient::Model.autoload_object rid.rid
  record.document.update_attributes attributes if attributes.present?
  record.document.save
  record.attributes.merge! attributes if attributes.present?
  record # return_value
end
update_document(java_document) click to toggle source

returns a valid model-instance

# File lib/java-api.rb, line 415
def update_document java_document
  if java_document.is_a? Document
    o_class =  java_document.class_name
    java_document.save
    d =  java_document
    ActiveOrient::Model.get_model_class(o_class).new  java_document
  else
    logger.progname = 'JavaApi#UpdateDocument'
    logger.error{ "Wrong Parameter: #{java_document.inspect} "}
  end
end
upsert(o_class, set: {}) { |new_record| ... } click to toggle source
# File lib/java-api.rb, line 239
def upsert o_class, set: {}, where: {} 
  logger.progname = 'JavaApi#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}" 
    result =  @db.run_command command

    case result
    when  Java::JavaUtil::ArrayList
      update_document result[0]
    when ActiveOrient::Model
      result   # just return the result
    when String, Numeric
      the_record=  get_records(from: o_class, where: where, limit: 1).pop
      if result.to_i == 1  # one dataset inserted, block is specified
        yield the_record   
      end
      the_record # return_value
    else
      logger.error{ "Unexpected result form Query \n  #{command} \n Result: #{result}" }
    end
  end
end