active-orient 0.6 → 0.42

data/examples/test_commands_3.rb

@@ -1,48 +0,0 @@
-require 'awesome_print'
-require_relative "../lib/active-orient.rb"
-
-# Start server
-ActiveOrient::OrientDB.default_server= { user: 'root', password: 'tretretre' }
-
-# Select database
-r = ActiveOrient::OrientDB.new database: 'NewTest'
-
-doc1 = r.create_class "DocumentTest"
-ver1 = r.create_vertex_class "VertexTest"
-a = doc1.create name: "Doc1"
-v = ver1.create name: "Ver"
-
-out = doc1.orientdb_class name: "Doc2345" # Used to instantiate an ActiveOrient Model
-print "1 #{out} \n"
-
-out = ver1.autoload_object "16:35" # Used to get a record by rid
-print "2 #{out} \n"
-
-print "3 #{ver1.superClass} \n" # Check superClass of the class
-
-print "4 #{v.class} \n"
-
-print "5 #{doc1}  \n"
-
-print "6 #{a}  \n"
-
-print "7 #{v}  \n"
-
-a = v.classname # Class of v
-print "8 #{a} \n"
-
-a = v.rid
-print "9 #{a} \n" # RID of v
-
-a = ver1.count where: {name: "Ver"}
-print "10 #{a} \n"
-
-print "11 #{v.to_human} \n" # Human version
-
-print "12 #{v.content_attributes} \n" # Return attributes
-
-print "13 #{v.default_attributes} \n" # Return created and updated
-
-print "14 #{v.set_attribute_defaults} \n" # Set up
-
-print "15 #{v.metadata} \n" # Set up

data/examples/test_commands_4.rb

@@ -1,28 +0,0 @@
-require_relative "../lib/active-orient.rb"
-
-ActiveOrient::OrientDB.default_server = { user: 'root', password: 'tretretre' }
-r = ActiveOrient::OrientDB.new database: 'NewTest'
-
-doc1 = r.open_class "DocumentTest" # Create Document/Vertex/Edge class
-doc2 = r.open_class "DocumentArrive_Test"
-doc1.create_property :familyname, type: :string
-doc1.create_property :family, type: :linkset, other_class: "DocumentTest"
-
-a1 = doc1.create name: "DocA", value: 34
-a2 = doc1.create name: "DocB", value: 34
-a3 = doc1.create name: "DocC", value: 34
-a4 = doc1.create name: "DocD", value: 30
-doc1.create name: "DocE", value: 30
-doc1.create name: "DocF", value: 30
-
-print "#{a1.ciao} \n"
-a1.family = [a2, a3]
-print "#{a1["family"].name} \n"
-print "---> #{a1.family.class}\n"
-a1["family"] << a4
-print "#{a1.family.name} \n"
-
-
-# ActiveOrient::OrientDB.methods.each do |m|
-# print "#{m} \n"
-# end

data/examples/time_graph.md

@@ -1,162 +0,0 @@
-The Time-Graph Example is outsourced  and lives as a seperate gem.
-
-https://github.com/topofocus/orientdb_time_graph
-
-from the readme: 
-
-# Time Graph 
-
-Simple Time Graph using ActiveOrient/OrientDB. 
-
-*Prerequisites* : 
-* Install and setup OrientDB
-* Run "Bundle install" and "Bundle update"
-* customize config/connect.yml
-
-**or** start a new project and include the gem in the usual manner.
-
-To play around, start the console by
-```
-  cd bin
-  ./active-orient-console t  # test-modus
-```
-The Database is automatically initialized and the following hierarchy is build:
-
-```ruby
-- E				# ruby-class
-- - month_of		      TG::MONTH_OF
-- - day_of		      TG::DAY_OF
-- - time_of		      TG::TIME_OF
-- - grid_of		      TG::GRID_OF
-- V
-- - time_base		      TG::TimeBase
-- - - jahr		      TG::Jahr
-- - - monat		      TG::Monat
-- - - stunde		      TG::Stunde
-- - - tag		      TG::Tag
-```
-This Graph is realized
-
-```ruby
-Jahr -- [Month_of] -- Monat --[DAY_OF]-- Tag --[TIME_OF]-- Stunde
-```
-and populated by calling 
-
-```ruby
-TG::TimeGraph.populate( a single year or a range )  # default: 1900 .. 2050
-```
-If only one year is specified, a Monat--Tag--Stunde-Grid is build, otherwise a Jahr--Monat--Tag one.
-You can check the Status by calling 
-
-```ruby
-TG::TimeGraph.populate 2000 -2003
-TG.info
--------------- TIME GRAPH ------------------
-Allocated Years : 
-2000; 2001; 2002; 2003 
-
-```
-In the Model-directory, customized methods simplify the usage of the graph.
-
-Some Examples:
-Assuming, you build a standard day-based grid
-
-```ruby
-
-include TG					# we can omit the TG prefix
-
-Jahr[2000]    # --> returns a single object
-=> #<TG::Jahr:0x00000004ced160 @metadata={"type"=>"d", "class"=>"jahr", "version"=>13, "fieldTypes"=>"out_month_of=g", "cluster"=>34, "record"=>101}, @d=nil, @attributes={"value"=>2000, "out_month_of"=>["#53:1209", "#54:1209", "#55:1209", "#56:1209", "#53:1210", "#54:1210", "#55:1210", "#56:1210", "#53:1211", "#54:1211", "#55:1211", "#56:1211"], "created_at"=>Fri, 09 Sep 2016 10:14:30 +0200}>
-
-
-Jahr[2000 .. 2005].value  # returns an array
- => [2003, 2000, 2004, 2001, 2005, 2002] 
-
-Jahr[2000 .. 2005].monat(5..7).value  # returns the result of the month-attribute (or method)
- => [[5, 6, 7], [5, 6, 7], [5, 6, 7], [5, 6, 7], [5, 6, 7], [5, 6, 7]] 
-
-Jahr[2000].monat(4, 7).tag(4, 15,24 ).datum  # adresses methods or attributes of the specified day's
- => [["4.4.2000", "15.4.2000", "24.4.2000"], ["4.7.2000", "15.7.2000", "24.7.2000"]] 
- ## unfortunatly »Jahr[2000 .. 2015].monat( 3,5 ).tag( 4 ..6 ).datum « does not fits now
- ## instead »Jahr[2000..2015].map{|y| y.monat( 3,5 ).tag( 4 ..6 ).datum } « does the job.
-```
-
-To filter datasets in that way, anything represented is queried from the database. In contrast to
-a pure ruby implementation, this works for small and large grid's.
-
-Obviously, you can do neat ruby-array playings, which are limited to the usual sizes.
-For example. As »TAG[31]« returns an array, the elements can be treated with ruby flavour:
-
-```ruby
-
-Tag[31][2..4].datum  # display three months with 31 days 
- => ["31.10.1901", "31.1.1902", "31.5.1902"]
-
-```
-First all Tag-Objects with the Value 31 are queried. This gives »Jan, Mar, May ..«. Then one can inspect the array, in this case by slicing a range.
-
-Not surprisingly, the first occurence of the day is not the earliest date in the grid. Its just the first one,
-fetched from the database.
-
-``` ruby
-Tag[1][1].datum
-=> "1.5.1900"    # Tag[1][0] correctly fetches "1.1.1900"
-Tag[1].last.datum
- => "1.11.2050"
- ## however, 
-Jahr[2050].monat(12).tag(1)  # exists:
-=> [["1.12.2050"]]
-```
-
-## Horizontal Connections
-
-Besides the hierarchically TimeGraph »Jahr <-->Monat <--> Tag <--> Stunde«  the Vertices are connected
-horizontally via »grid_to«-Edges. This enables an easy access to the neighbours.
-
-On the TG::TimeBase-Level a method »environment« is implemented, that gathers the adjacent vertices 
-via traverse.
-
-``` ruby
-start =  TG::Jahr[2000].monat(4).tag(7).first.first
-start.environment(3).datum
- => ["4.4.2000", "5.4.2000", "6.4.2000", "7.4.2000", "8.4.2000", "9.4.2000", "10.4.2000"] 
-
-2.3.1 :003 > start.environment(3,4).datum
- => ["4.4.2000", "5.4.2000", "6.4.2000", "7.4.2000", "8.4.2000", "9.4.2000", "10.4.2000", "11.4.2000"] 
- 
-start.environment(0,3).datum
- => ["7.4.2000", "8.4.2000", "9.4.2000", "10.4.2000"] 
-```
-
-
-
-## Diary
-
-lets create a simple diary
-
-```ruby
-include TG
-TimeiGraph.populate 2016
-ORD.create_vertex_class :termin
- => Termin
-ORD.create_edge_class   :date_of
- => DATE_OF
-DATE_OF.uniq_index	# put contrains to the edge-class, accept only one entry per item 
-
-DATE_OF.create from: Monat[8].tag(9).stunde(12), 
-	       to: Termin.create( short: 'Mittagessen', 
-				  long: 'Schweinshaxen essen mit Lieschen Müller', 
-				  location: 'Hofbauhaus, München' )
- => #<DATE_OF:0x0000000334e038 (..) @attributes={"out"=>"#21:57", "in"=>"#41:0", (..)}> 
-# create some regular events
-# attach breakfirst at 9 o clock from the 10th to the 21st Day in the current month
-DATE_OF.create from: Monat[8].tag(10 .. 21).stunde( 9 ), to: Termin.create( :short => 'Frühstück' )
- => #<DATE_OF:0x000000028d5688 @metadata={(..) "cluster"=>45, "record"=>8}, 
-			      @attributes={"out"=>"#22:188", "in"=>"#42:0",(..)}>
-
-t = Termin.where short: 'Frühstück'
-t.in_date_of.out.first.datum
-  => ["10.8.2016 9:00", "11.8.2016 9:00", "12.8.2016 9:00", "13.8.2016 9:00", "14.8.2016 9:00", "15.8.2016 9:00", "16.8.2016 9:00", "17.8.2016 9:00", "18.8.2016 9:00", "19.8.2016 9:00", "20.8.2016 9:00", "21.8.2016 9:00"]
-
-```
-

data/gratefuldeadconcerts.md

@@ -1,94 +0,0 @@
-# Experiments with the GratefuldDeadConcterts database
-
-First modify the database-entry (development) in /config/connect.yml to  «GreatfulDeadConerts».
-This should be present after the installation of the database
-Then execute « ./bin/active-orient-console d »
-```
-Present Classes (Hierarchy) 
-  ---
-  - - E
-  - - followed_by
-  - sung_by
-  - written_by
-  - V
-
-  Active Classes  ->  ActiveOrient ClassName
-  ---------------------------------------------
-  V ->  V
-  E ->  E
-  followed_by ->  FollowedBy
-  sung_by ->  SungBy
-  written_by ->  WrittenBy
-  ---------------------------------------------
-```
-
-Lets start with simple queries
-
-* Select all vertices (or object) in the database
-
-```ruby
-V.all
-```
-
-* Select the vertex with the id #9:8
-```ruby
-V.autoload_object '#9:8'
-```
-
-* Select all the artists
-
-```ruby
-V.where type: 'artist'
-```
-
-* Select all the songs that have been performed  10 times 
-
-Display songnames and authors
-
-
-```ruby
-song_10 = V.where type: 'song', performances:  10
-song_10.name
-=> ["TOMORROW IS FOREVER", "SHE BELONGS TO ME", "UNBROKEN CHAIN"]
-song_10.out_written_by.in.name 
-=> [["Dolly_Parton"], ["Bob_Dylan"], ["Petersen"]]
-```
-* Select all the songs that have been performed  more or less 10 times 
-
-```ruby
-V.where "type = 'song’ and performances > 10"
-V.where "type = 'song’ and performances < 10"
-```
-* Count all songs and artists
-
-```ruby
-V.count where: { type: 'song' }
-V.count where: { type: 'song', performances:  10 }
-
-V.count where: { type: 'artist' }
-```
-
-
-* Find all songs sung by the first artist 
- 
-First get the artist
-```ruby
- first_artist = OrientSupport::OrientQuery.new from: artist_vertex, where: { type: 'artist'} , limit: 1
- first_artist.to_s => "select  from V where type = 'artist'  limit 1"
-```
-Traverse through the database. List any song and author that is sung by this artist
-
-```ruby
-songs = DB.execute{ "select expand(set(in('sung_by'))) from (#{first_artist.to_s}) " }
-songs.name
-==> ["ROSA LEE MCFALL", "ROW JIMMY", "THAT WOULD BE SOMETHING", "BETTY AND DUPREE", "WHISKEY IN THE JAR", ...]
-
-authors = DB.execute{ "select expand(set(in('sung_by').out('written_by'))) from (#{first_artist.to_s}) " }
-authors.name
-==>  ["Bob_Dylan", "Chuck_Berry", "Unknown", "Bernie_Casey_Pinkard", ...]
-
-```
-
-go [Back](./README.md) to the introduction page
-
-

data/lib/class_utils.rb

@@ -1,300 +0,0 @@
-module ClassUtils
-  # ClassUitils is included in Rest- and Java-Api-classes
-
-=begin
-  Returns a valid database-class name, nil if the class does not exists
-=end
-
-  def classname name_or_class  # :nodoc:
-    name = case  name_or_class
-	when ActiveOrient::Model
-              name_or_class.class.ref_name
-	when Class
-              name_or_class.ref_name
-#	      name_or_class.to_s.split('::').last
-	else
-	  name_or_class.to_s.split(':').last #.to_s.camelcase # capitalize_first_letter
-    end
-    ## 16/5/31  : reintegrating functionality to check wether the classname is 
-    #		  present in the database or not
-          if database_classes.include?(name)
-	             name
-	  elsif database_classes.include?(name.underscore)
-	           name.underscore
-	  else
-	     logger.progname =  'ClassUtils#Classname'
-	      logger.warn{ "Classname #{name_or_class.inspect} ://: #{name} not present in #{ActiveOrient.database}" }
-	  nil
-
-	  end
-  end
-=begin
-create a single class and provide properties as well
-
-  ORB.create_class( the_class_name as String or Symbol (nessesary) ,
-		    properties: a Hash with property- and Index-descriptions (optional)){
-		    {superclass: The name of the superclass as String or Symbol , 
-		     abstract: true|false } (optional Block provides a Hash ) }
-
-=end
- def create_class classname, properties: nil, &b
-   the_class= create_classes( classname, &b )
-    # if multible classes are specified, don't process properties
-    # ( if multible classes need the same properties, consider a nested class-design )
-   if the_class.is_a?(Array)
-     if the_class.size == 1
-       the_class = the_class.first
-     else
-       properties =  nil
-     end
-    end
-   create_properties( the_class.ref_name , properties )  if properties.present?
-   the_class # return_value
- end
-
-
-=begin
-AllocateClassesInRuby acts as a proxy to OrientdbClass,
-takes a classes-array as argument
-=end
-def allocate_classes_in_ruby classes  # :nodoc:
-    generate_ruby_object = ->( name, superclass, abstract ) do
-      begin
-	# if the class is predefined, use specs from get_classes
-	or_def =  get_classes('name', 'superClass', 'abstract' ).detect{|x| x['name']== name.to_s }
-	superclass, abstract = or_def.reject{|k,v| k=='name'}.values unless or_def.nil?
-      #print "GENERATE_RUBY_CLASS: #{name} / #{superclass} \n"
-	 m= ActiveOrient::Model.orientdb_class name: name,  superclass: superclass
-	 m.abstract = abstract
-	 m.ref_name = name.to_s
-      #puts "-->  #{m.object_id}"
-	 m
-      rescue NoMethodError => w
-	logger.progname = "ClassUtils#AllocateClassesInRuby"
-	logger.error{ w.message }
-	logger.error{ w.backtrace.map {|l| "  #{l}\n"}.join  }
-	nil
-#	raise
-      end 
-
-    end
-
-    superclass, abstract  = if block_given? 
-			      s =  yield
-			      if s.is_a? Hash
-				[s[:superclass],s[:abstract]]
-				else
-				  [s,false]
-			      end
-			    else
-			      [nil,false]
-			    end
-    #superclass_object = generate_ruby_object[superclass,nil,nil] if superclass.present?
-
-    consts = case classes 
-    when  Array
-      next_superclass=  superclass
-      classes.map do |singleclass|
-	if singleclass.is_a?( String) || singleclass.is_a?( Symbol)
-	next_superclass = generate_ruby_object[singleclass,superclass,abstract]
-	elsif singleclass.is_a?(Array) || singleclass.is_a?(Hash) 
-	  allocate_classes_in_ruby( singleclass){ {superclass: next_superclass, abstract: abstract}}
-	end
-      end
-    when Hash
-      classes.keys.map  do| h_superclass |
-[	generate_ruby_object[h_superclass,superclass,abstract], 
-        allocate_classes_in_ruby(classes[ h_superclass ]){{ superclass: h_superclass, abstract: abstract }} ]
-      end
-    when String, Symbol
-      generate_ruby_object[classes,superclass, abstract]
-    end
-    consts
-end
-=begin
-  Creating a new Database-Entry (where is omitted)
-  Or updating the Database-Entry (if present)
-
-  The optional Block should provide a hash with attributes (properties). These are used if a new dataset is created.
-  Based on the query specified in :where records are updated according to :set
-
-  Returns an Array of updated documents
-=end
-
-  def update_or_create_records o_class, set: {}, where: {}, **args, &b
-    logger.progname = 'ClassUtils#UpdateOrCreateRecords'
-    if where.blank?
-      [create_record(o_class, attributes: set)]
-    else
-  	  set.extract!(where.keys) if where.is_a?(Hash) # removes any keys from where in set
-  	  possible_records = get_records from: classname(o_class), where: where, **args
-    	if possible_records.empty?
-    	  if block_given?
-    	    more_where = yield   # do Preparations prior to the creation of the dataset
-          # if the block returns a Hash, it is merged into the insert_query.
-    	    where.merge! more_where if more_where.is_a?(Hash)
-    	  end
-    	  [create_record(o_class, attributes: set.merge(where))]
-    	else
-    	  possible_records.map{|doc| doc.update(set: set)} unless set.empty?
-    	end
-    end
-  end
-
-
-=begin
-  create_edge connects two vertexes
-
-  The parameter o_class can be either a class or a string
-
-  if batch is specified, the edge-statement is prepared and returned 
-  else the statement is transmitted to the database
-
-  The method takes a block as well. 
-  It must provide a Hash with :from and :to- Key's, e.g.
-  Vertex1, Vertex2 are two vertex-classes and TheEdge is an edge-class
-
-      record1 = ( 1 .. 100 ).map{ |y| Vertex1.create( testentry: y } }
-      record2 = ( :a .. :z ).map{ |y| Vertex2.create( testentry: y } }
-
-      edges = ORD.create_edge( TheEdge ) do | attributes |
-	 ('a'.ord .. 'z'.ord).map do |o| 
-	       { from: record1.find{|x| x.testentry == o },
-		 to:   record2.find{ |x| x.testentry.ord == o },
-		 attributes: attributes.merge{ key: o.chr } }
-	  end
-  or
-
-      edges = ORD.create_edge( TheEdge ) do | attributes |
-	 ('a'.ord .. 'z'.ord).map do |o| 
-	       { from: Vertex1.where( testentry:  o ).pop ,
-		 to:   Vertex2.where( testentry.ord =>  o).pop ,
-		 attributes: attributes.merge{ key: o.chr } }
-	  end
-
-  Benefits: The statements are transmitted as batch.
-
-  The pure-ruby-solution minimizes traffic to the database-server and is prefered.
-
-=end
-  def create_edge o_class, attributes: {}, from:nil, to:nil, unique: false, batch: nil  
-    logger.progname = "ClassUtils#CreateEdge"
-
-# -------------------------------
-    create_command =  -> (attr, from, to ) do
-      attr_string =  attr.blank? ? "" : "SET #{generate_sql_list attr}"
-      if from.present? && to.present? 
-      [from, to].each{|y| remove_record_from_hash y }
-      { type: "cmd",
-	  language: 'sql',
-	  command: "CREATE EDGE #{classname(o_class)} FROM #{from.to_orient} TO #{to.to_orient} #{attr_string}"
-		      }
-      end
-    end
-# -------------------------------
-
-    if block_given?
-      a =  yield(attributes)
-      command = if a.is_a? Array
-		  batch =  nil
-		  command=  a.map do | record | 
-#		  puts record.inspect
-		    this_attributes =  record[:attributes].presence || attributes
-		    create_command[ this_attributes, record[:from],  record[:to]]
-		  end
-		else
-		  this_attributes =  a[:attributes].presence || attributes
-		  command = create_command[ this_attributes, a[:from],  a[:to]]
-		end
-    elsif from.is_a?( Array ) && to.is_a?(Array)
-      command = Array.new
-      while from.size >1
-	this_attributes = attributes.is_a?(Array) ? attributes.shift : attributes
-	command << create_command[ this_attributes, from.shift, to.shift]
-      end
-    elsif from.is_a? Array
-      command = from.map{|f| create_command[ attributes, f, to] }
-    elsif to.is_a? Array
-      command = to.map{|f| create_command[ attributes, from, f] }
-#      puts "COMMAND: #{command.inspect}"
-    elsif from.present? && to.present?
-      #      if unique
-      #	wwhere = {out: from.to_orient, in: to.to_orient }.merge(attributes.to_orient)
-      #	existing_edge = get_records(from: o_class, where: wwhere)
-      #	if existing_edge.size >1 
-      #	  logger.error{ "Unique specified, but there are #{existing_edge.size} Records in the Database. returning the first"}
-      #	  command =  existing_edge.first
-      #	  batch = true
-      #	elsif existing_edge.size ==1  && existing_edge.first.is_a?(ActiveOrient::Model)
-      #	  #logger.debug {"Reusing edge #{classname(o_class)} from #{from.to_orient} to #{to.to_orient}"}
-      #	  command=  existing_edge.first
-      #	  batch= true
-      #	else
-      command = create_command[ attributes, from, to]
-      #	end
-      #	#logger.debug {"Creating edge #{classname(o_class)} from #{from.to_orient} to #{to.to_orient}"}
-      #
-    elsif from.to_orient.nil? || to.to_orient.nil? 
-      logger.error{ "Parameter :from or :to is missing"}
-    else 
-      # for or to are not set
-      return nil
-    end
-#   puts "RUNNING EDGE: #{command.inspect}"
-    if command.present?
-      begin
-	response = execute(transaction: false, tolerated_error_code: /found duplicated key/) do
-	  command.is_a?(Array) ? command.flatten.compact : [ command ]
-	end
-	if response.is_a?(Array) && response.size == 1
-	  response.pop # RETURN_VALUE
-	else
-	  response  # return value (the normal case)
-	end
-      rescue ArgumentError => e
-	puts "ArgumentError "
-	puts e.inspect
-      end  # begin
-    end
-
-  end
-=begin
-Deletes the specified vertices and unloads referenced edges from the cache
-=end
-  def delete_vertex *vertex
-    create_command =  -> do
-      { type: "cmd",
-	  language: 'sql',
-	  command: "DELETE VERTEX #{vertex.map{|x| x.to_orient }.join(',')} "
-		      }
-      end
-
-    vertex.each{|v| v.edges.each{| e | remove_record_from_hash e} }
-    execute{ create_command[] }
-  end
-
-=begin
-Deletes the specified edges and unloads referenced vertices from the cache
-=end
-  def delete_edge *edge
-    create_command =  -> do
-      { type: "cmd",
-	  language: 'sql',
-	  command: "DELETE EDGE #{edge.map{|x| x.to_orient }.join(',')} "
-		      }
-      end
-
-    edge.each do |r|
-      [r.in, r.out].each{| e | remove_record_from_hash e}
-      remove_record_from_hash r
-    end
-    execute{ create_command[] }
-  end
-
-  private
-	def remove_record_from_hash r
-	  obj= ActiveOrient::Base.get_rid(r.rid) unless r.nil?
-	  ActiveOrient::Base.remove_rid( obj ) unless obj.nil?
-	end
-
-end # module