active-orient 0.3 → 0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: babcbd90fcc89be93302da2907357f3049ec4ae4
-  data.tar.gz: a5a95791f21342e4272f58a777febe243f25af3f
+  metadata.gz: d00a72ebc77faf7333a31a4b5c73f17554ccfc88
+  data.tar.gz: 62cd8f3823a629dba2f10e8b91b7841c9359c29d
 SHA512:
-  metadata.gz: c38d7aa2efb71e1d240f613fb9b1dd72475f846601f18a8b3d7fc1bfd9c49da289a8d4e64bf9f0cd765bf8a693ef2ed8fd079ea84bb806b830d92d4ee1b27301
-  data.tar.gz: d9a94362684f5f988cc6f667c91e9094b77bf487d895dbbeab51321160d6377bc7515db4ec3bedfb3ed41846739313b3c27d9cff58a366b369b07390a88cccb5
+  metadata.gz: bdae72102cee0e3c39c07c74715e9167878e9be90f27d12da827dbae7419c0105adf77bb9cc43ecc6bcd5ae80c1f394bff8795865d3014d70758bc9f562a4d8b
+  data.tar.gz: 54415683a7bda1bfac78d73cf668fc93be875f654de0257e67f9c2a85963ef1315e156c2517b795713a4067635b6269710294a1cc2d74f09069de011a751b5ef

data/Gemfile

@@ -3,6 +3,7 @@ gemspec
 gem 'activesupport' ,  "~>4.2"
 gem 'activemodel'
 gem 'rest-client', :git => 'git://github.com/rest-client/rest-client.git'
+gem 'nokogiri', '~> 1.6.6' #, :git => 'git://github.com/sparklemotion/nokogiri.git'
 group :development, :test do
 	gem "rspec"
 	gem 'rspec-its'

data/README.md

@@ -197,9 +197,57 @@ The Attributes "in" and "out" can be used to move across the graph
    start.e1[0].in.something 
    ---> "nice
 ```
+#### Queries
+Contrary to traditional SQL-based Databases OrientDB handles  subqueries very efficient. 
+In addition, OrientDB supports precompiled statements (let-Blocks).
+
+ActiveOrient is equipped with a simple QueryGenerator: ActiveSupport::OrientQuery. 
+It works in two modi: a comprehensive and a subsequent one
+```ruby
+  
+  q =  OrientSupport::OrientQuery.new
+  q.from = Vertex  
+  q.where << a: 2
+  q.where << 'b > 3 '
+  q.distinct = :profession
+  q.order =  { :name => :asc }
+
+```
+is equivalent to
+```ruby
+  q =  OrientSupport::OrientQuery.new from:  Vertex , 
+				      where: [{ a: 2 }, 'b > 3 '],
+				      distinct:  :profession,
+				      order:  { :name => :asc }
+  q.to_s
+  => select distinct( profession ) from Vertex where a = 2 and b > 3  order by name asc
+```
+Both modes can be mixed.
+
+If subqueries are nessesary, they can be introduced as OrientSupport::OrientQuery or as »let-block«.
+```ruby
+  q =  OrientSupport::OrientQuery.new from: 'ModelQuery'
+  q.let << "$city = adress.city"
+  q.where = "$city.country.name = 'Italy' OR $city.country.name = 'France'"
+  q.to_s
+  => select from ModelQuery let $city = adress.city where $city.country.name = 'Italy' OR $city.country.name = 'France' 
+```
+or
+```ruby
+  q =  OrientSupport::OrientQuery.new
+  q.let << { a:  OrientSupport::OrientQuery.new( from: '#5:0' ) }
+  q.let << { b:  OrientSupport::OrientQuery.new( from: '#5:1' ) }
+  q.let << '$c= UNIONALL($a,$b) '
+  q.projection << 'expand( $c )'
+  q.to_s
+  => select expand( $c ) let $a = ( select from #5:0 ), $b = ( select from #5:1 ), $c= UNIONALL($a,$b)
+```
+
+
+
 
 #### Execute SQL-Commands
-At least - sql-commands can be executed as batch
+Sql-commands can be executed as batch
 
 The ActiveOrient::Query-Class provides a Query-Stack and an Records-Array which keeps the results.
 The ActiveOrient::Query-Class acts as Parent-Class for aggregated Records (without a @rid), which are ActiveOrient::Model::Myquery Objects. If a Query returns a database-record, the correct ActiveOrient::Model-Class is instantiated.

data/VERSION

@@ -1 +1 @@
-0.3
+0.4

data/active-orient.gemspec

@@ -22,6 +22,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "bundler", "~> 1.8"
   s.add_development_dependency "rake", "~> 10.0"
   s.add_dependency 'activesupport', "~> 4.2"
-  s.add_dependency 'rest-client', "~> 2.0.0.alpha"
+  s.add_dependency 'rest-client', "~> 2.0"
 
 end

data/examples/books.rb

@@ -0,0 +1,78 @@
+=begin
+Books Example
+
+There are several Books. And there is a Table with Keywords. These are our Vertex-Classes
+
+The Keywords are associated to the books, this is realized via an Edge »has_content«
+
+This Example demonstrates how to build a query by using OrientSupport::OrientQuery
+=end
+ class BooksExample
+
+    def initialize db, rebuild: true
+      if rebuild
+      db.delete_class :book
+      db.delete_class :keyword
+      db.delete_class :has_content
+      db.create_vertex_class :book
+      db.create_vertex_class :keyword
+      db.create_edge_class :has_content
+      ActiveOrient::Model::Keyword.create_property( :item , type: :string, index: :unique )
+      ActiveOrient::Model::Book.create_property( :title, type: :string, index: :unique )
+      end
+    end
+
+
+      def read_samples
+	fill_database = ->(sentence, this_book ) do 
+	  sentence.split(' ').each do |x| 
+	    this_word = Keyword.update_or_create where: { item: x }
+	    this_edge = HC.create_edge from: this_book, to: this_word  if this_word.present?
+	  end 
+	end
+	words = 'Die Geschäfte in der Industrie im wichtigen US-Bundesstaat New York sind im August so schlecht gelaufen wie seit mehr als sechs Jahren nicht mehr Der entsprechende Empire-State-Index fiel überraschend von plus  Punkten im Juli auf minus 14,92 Zähler Dies teilte die New Yorker Notenbank Fed heut mit Bei Werten im positiven Bereich signalisiert das Barometer ein Wachstum Ökonomen hatten eigentlich mit einem Anstieg auf 5,0 Punkte gerechnet'
+	this_book =  Book.create title: 'first'
+	fill_database[ words, this_book ]
+
+	words2 = 'Das Bruttoinlandsprodukt BIP in Japan ist im zweiten Quartal mit einer aufs Jahr hochgerechneten Rate von Prozent geschrumpft Zu Jahresbeginn war die nach den USA und China drittgrößte Volkswirtschaft der Welt noch um  Prozent gewachsen Der Schwächeanfall wird auch als Rückschlag für Ministerpräsident Shinzo Abe gewertet der das Land mit einem Mix aus billigem Geld und Konjunkturprogramm aus der Flaute bringen will Allerdings wirkte sich die heutige Veröffentlichung auf die Märkten nur wenig aus da Ökonomen mit einem schwächeren zweiten Quartal gerechnet hatten'
+	this_book =  Book.create title: 'second'
+	fill_database[ words2, this_book ]
+      end
+  
+    def display_books_with *desired_words
+      query = OrientSupport::OrientQuery.new  from: Keyword, projection: "expand(in('HasContent'))"
+      q =  OrientSupport::OrientQuery.new projection: 'expand( $z )'
+
+      intersects = Array.new
+      desired_words.each_with_index do | word, i |
+	       symbol = ( i+97 ).chr   #  convert 1 -> 'a' 
+	       query.where = { item: word  }
+               q.let << { symbol =>  query }
+	       intersects << "$#{symbol}"		 
+      end
+      q.let <<  "$z = Intersect(#{intersects.join(', ')}) "
+      puts "generated Query:"
+      puts q.to_s
+      result = Keyword.query_database  q, set_from: false
+      puts "found books: "
+      puts result.map( &:title ).join("; ") 
+      puts " -- None -- " if result.empty?
+    end
+ end
+
+if $0 == __FILE__
+
+require '../config/boot'
+
+    ActiveOrient::OrientDB.default_server = { user: 'hctw', password: 'hc' }
+    ActiveOrient::OrientDB.logger.level = Logger::WARN
+    r = ActiveOrient::OrientDB.new database: 'BookTest'
+    b= BooksExample.new r, rebuild:  true 
+      
+    Book = r.open_class :book
+    Keyword = r.open_class :keyword
+    HC = r.open_class :has_content
+   
+    b.read_samples if Keyword.count.zero?
+    b.display_books_with 'Land', 'Quartal'
+end

data/examples/streets.rb

@@ -0,0 +1,129 @@
+=begin
+Streets Example
+
+
+We load german cities from wikipedia and parse the document for cities and countries(states).
+Further we load a collection of popular streetnames from a web-side called »strassen-in-deutschland«
+
+We define three vertices, State, City and Street.
+These are filled with the data from the web-sides
+
+Then we connect the cities through streets just by creating edges.
+At last we print the connected cities.
+
+=end
+module DataImport
+  def read_german_street_names
+    doc = Nokogiri::HTML(open('http://www.strassen-in-deutschland.de/die-haeufigsten-strassennamen-in-deutschland.html'))
+    strassen = doc.css('#strassen-in-deutschland_main a' ) # identified via css-inspector in browser
+    # search for the css and include only links, then display the text-part
+    strassen.children.map( &:to_s )[3..-1]  # omit the first three (strassen in deutschland, straßenverzeichnis, straßen)
+  end
+
+  def read_german_cities_from_wikipedia 
+    # we extract <li> -elements and use the text until "(" 
+    #doc.xpath("//li").at(80)
+    # => #<Nokogiri::XML::Element:0x1ba551c name="li" children=[#<Nokogiri::XML::Element:0x1ba533c name="a" attributes=[#<Nokogiri::XML::Attr:0x1ba52d8 name="href" value="/wiki/Angerm%C3%BCnde">, #<Nokogiri::XML::Attr:0x1ba52c4 name="title" value="Angermünde">] children=[#<Nokogiri::XML::Text:0x1ba4c84 "Angermünde">]>, #<Nokogiri::XML::Text:0x1ba4ae0 " (Brandenburg)">]> 
+
+    doc = Nokogiri::HTML(open('https://en.wikipedia.org/wiki/List_of_cities_and_towns_in_Germany'))
+    doc.xpath("//li").map{|x| x.text[0 .. x.text.index('(')-2] if x.text.index('(').present? }.compact
+  end
+
+  def read_german_cities_and_states_fom_wikipedia
+    doc =
+      Nokogiri::HTML(open('https://en.wikipedia.org/wiki/List_of_cities_and_towns_in_Germany'))
+    doc.xpath("//li").map do |x| 
+      if x.text.index('(').present? 
+	[ x.text[0 .. x.text.index('(')-2] , x.text[ x.text.index('(')+1 .. x.text.index(')')-1] ]
+      end
+    end.compact
+  end 
+
+end # module
+
+ class StreetExample
+
+   include  DataImport
+    def initialize db, rebuild: true
+      if rebuild
+	ActiveOrient::OrientDB.logger.progname = "StreetsExample#Initialize"
+	db.delete_class :state
+	db.delete_class :city
+	db.delete_class :street
+	db.delete_class :connects
+	db.create_vertex_class :state 
+	db.create_vertex_class :city
+	db.create_vertex_class :street
+	db.create_edge_class :connects
+	ActiveOrient::Model::State.create_property( :name, type: :string, index: :unique )
+	ActiveOrient::Model::City.create_properties(  { name: { type: :string },
+			    state: { type: :link, :linked_class => 'State' } } 
+			      ) do
+				{ citi_idx: :unique } 
+			      end
+	ActiveOrient::Model::Street.create_property :name , type: :string, index: :notunique 
+	ActiveOrient::Model::Connects.create_property :distance, type: :integer, index: :notunique 
+	ActiveOrient::OrientDB.logger.info { "Vertex- and Edge-Classes rebuilded" }
+      end
+    end
+
+
+    def read_from_web
+      ActiveOrient::OrientDB.logger.progname = "StreetsExample#ReadFromWeb"
+      read_german_cities_and_states_fom_wikipedia.each do |city,state| 
+	state =  State.update_or_create( where: { name: state }).first
+	City.create name: city, state: state.link
+      end
+      ActiveOrient::OrientDB.logger.info { "#{City.count} Cities imported from Wikipedia " }
+
+      cities_rids =  City.all.map &:link
+      read_german_street_names.each_with_index do |street, i|
+	street_record =  Street.create name: street
+	count = i
+	cities =  Array.new
+	while  count < cities_rids.size && cities.size < 5 do
+	  cities << cities_rids[count] 
+	  count =  count + i 
+	end
+	C.create_edge :from => street_record,  :to => cities
+      end
+      ActiveOrient::OrientDB.logger.info { "#{C.count} Edges between Streets and Cities created " }
+    end
+  
+    def display_streets_per_state
+      State.all.each do |state|
+	streets= Street.all.map do |street |
+	  if street.connects.in.detect{|x| x.state == state }
+	    street.name + " verbindet " + street.connects.in.map( &:name ).join('; ')
+	  end
+	end.compact
+	unless streets.empty?
+	  puts "..................................."
+	  puts state.name
+	  puts "..................................."
+	  puts streets.join("\n")
+	end
+      end
+    end
+ end
+
+if $0 == __FILE__
+
+require '../config/boot'
+require 'open-uri'
+require 'nokogiri'
+
+    ActiveOrient::OrientDB.default_server= { user: 'hctw', password: 'hc' }
+    r = ActiveOrient::OrientDB.new database: 'StreetTest'
+    ActiveOrient::OrientDB.logger.level = Logger::INFO
+    s= StreetExample.new r, rebuild:  true 
+      
+    City = r.open_class :city
+    State = r.open_class :state
+    Street = r.open_class :street
+    C = r.open_class :connects
+    
+    s.read_from_web if City.count.zero?
+    s.display_streets_per_state
+
+end

data/lib/model.rb

@@ -105,20 +105,20 @@ eg .  update #link set  ...
    end
 
 
-   def method_missing method, *args, &b
-     property=  orientdb.get_class_properties( classname )['properties'].detect{|x| x.has_value?  method.to_s }
-     puts "method_missing::property"
-     puts property.inspect
-     if property.present?
-       if property['type'] == 'LINKSET'
-	 attributes[method] = OrientSupport::Array.new( self )
-       else
-	 attributes[method] = ''
-       end
-     else
-	 raise NoMethodError
-     end
-   end
+#   def method_missing method, *args, &b
+#     property=  orientdb.get_class_properties( classname )['properties'].detect{|x| x.has_value?  method.to_s }
+#     puts "method_missing::property"
+#     puts property.inspect
+#     if property.present?
+#       if property['type'] == 'LINKSET'
+#	 attributes[method] = OrientSupport::Array.new( self )
+#       else
+#	 attributes[method] = ''
+#       end
+#     else
+#	 raise NoMethodError
+#     end
+#   end
 =begin 
 Queries the database and fetches the count of datasets
 
@@ -149,11 +149,22 @@ and returns the freshly instantiated Object
 =begin
 Create a Property in the Schema of the Class
  :call-seq: 
-  self.create_property  field (required) , type: 'string', linked_class: nil
+  self.create_property(  field (required) , type: 'string', linked_class: nil, index: nil)  do
+	      index
+	end
 =end
 
-   def self.create_property field, **keyword_arguments 
-     orientdb.create_property  self, field,  **keyword_arguments 
+   def self.get_properties 
+     object =  orientdb.get_class_properties self
+     {:properties => object['properties'] , :indexes => object['indexes'] }
+   end
+
+   def self.create_property field, **keyword_arguments, &b
+     orientdb.create_property  self, field,  **keyword_arguments, &b
+   end
+
+   def self.create_properties argument_hash, &b
+     orientdb.create_properties self, argument_hash, &b
    end
 
    def self.create_link name, class_name
@@ -167,15 +178,23 @@ Only if the Class inherents from »E«
 Instantiate a new Edge betwen two Vertices
 
 Parameter: unique: (true)  In case of an existing Edge just update its Properties. 
+The parameters »from« and »to« can take a list of model-records. Then subsequent edges are created.
  :call-seq: 
   self.create_edge from: , to: , unique: false, attributes:{} 
 =end
    def self.create_edge **keyword_arguments 
       o=orientdb.nexus_edge  self, **keyword_arguments 
-      [:from,:to].each{|y| keyword_arguments[y].reload! }
+      [:from,:to].each{|y| keyword_arguments[y].is_a?(Array) ? keyword_arguments[y].each( &:reload! ):  keyword_arguments[y].reload! }
       o  # return_value
    end
 
+   def self.query_database query, set_from: true
+     query.from self if set_from && query.is_a?( OrientSupport::OrientQuery ) && query.from.nil? 
+     sql_cmd = -> (command) { { type: "cmd", language: "sql", command: command } }
+     orientdb.execute do
+       [ sql_cmd[ query.to_s ] ]
+     end 
+   end
    def query  q 
      a= ActiveOrient::Query.new 
      a.queries << q
@@ -243,7 +262,7 @@ prints a Table with 10 columns.
 =end
 
    def self.get_documents **args , &b
-     orientdb.get_documents from: classname,  **args, &b
+     orientdb.get_documents from: self,  **args, &b
     
    end
 =begin
@@ -258,7 +277,8 @@ Example:
 
 =end
 def self.where attributes =  {}
-  orientdb.get_documents  from: self, where: attributes
+  q = OrientSupport::OrientQuery.new where: attributes
+  query_database q 
 end
 =begin
 

data/lib/rest.rb

@@ -358,26 +358,33 @@ The parameter o_class can be either a class or a string
 
     def nexus_edge o_class , attributes: {}, from:,  to:, unique: false
       logger.progname = "ActiveOrient::OrientDB#NexusEdge"
-      if unique
-	wwhere = { out: from.to_orient,  in: to.to_orient }.merge(attributes.to_orient) 
-	existing_edge = get_documents( from: o_class, where: wwhere )
-	if  existing_edge.first.is_a?( ActiveOrient::Model )
-	  logger.debug { "reusing  edge #{class_name(o_class)} from #{from.to_orient} to #{to.to_orient} " }
-	return existing_edge.first  
+      if from.is_a? Array
+	from.map{|f| nexus_edge o_class, attributes: attributes, from: f, to: to, unique: unique }
+      elsif to.is_a? Array
+	to.map{|t| nexus_edge o_class, attributes: attributes, from: from, to: t, unique: unique }
+      else
+
+	if unique
+	  wwhere = { out: from.to_orient,  in: to.to_orient }.merge(attributes.to_orient) 
+	  existing_edge = get_documents( from: o_class, where: wwhere )
+	  if  existing_edge.first.is_a?( ActiveOrient::Model )
+	    logger.debug { "reusing  edge #{class_name(o_class)} from #{from.to_orient} to #{to.to_orient} " }
+	    return existing_edge.first  
+	  end
+	end
+	logger.debug { "creating edge #{class_name(o_class)} from #{from.to_orient} to #{to.to_orient} " }
+	response=  execute( o_class, transaction: false) do 
+	  #[ { type: "cmd", language: 'sql', command:  CGI.escapeHTML("create edge #{class_name(o_class)} from #{translate_to_rid[m]} to #{to.to_orient}; ")} ]
+	  attr_string =  attributes.blank? ? "" : "set #{ generate_sql_list attributes.to_orient }"
+	  [ { type: "cmd", language: 'sql', 
+       command:  "create edge #{class_name(o_class)} from #{from.to_orient} to #{to.to_orient} #{attr_string}"} ]
+	end
+	if response.is_a?(Array) && response.size == 1
+	  response.pop # RETURN_VALUE
+	else
+	  response
 	end
       end
-      logger.debug { "creating edge #{class_name(o_class)} from #{from.to_orient} to #{to.to_orient} " }
-      response=  execute( o_class, transaction: false) do 
-      #[ { type: "cmd", language: 'sql', command:  CGI.escapeHTML("create edge #{class_name(o_class)} from #{translate_to_rid[m]} to #{to.to_roient}; ")} ]
-      attr_string =  attributes.blank? ? "" : "set #{ generate_sql_list attributes.to_orient }"
-      [ { type: "cmd", language: 'sql', 
-	  command:  "create edge #{class_name(o_class)} from #{from.to_orient} to #{to.to_orient} #{attr_string}"} ]
-       end
-       if response.is_a?(Array) && response.size == 1
-	 response.pop # RETURN_VALUE
-       else
-	 response
-       end
     end
 
 =begin
@@ -440,15 +447,49 @@ todo: remove all instances of the class
       end
 
     end
+=begin
+create a single property on class-level.
 
-    def create_property o_class, field, type: 'string', linked_class: nil
+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  
+
+=end
+    def create_property o_class, field, index: nil,  **args 
       logger.progname= 'OrientDB#CreateProperty'
-	js= if linked_class.nil?
-	 { field => { propertyType: type.upcase } }
-	    else
-	 { field => { propertyType: type.upcase,  linkedClass: class_name( linked_class ) } }
-	    end
-	create_properties( o_class ){ js }
+	c= create_properties o_class,   {field =>  args} # translate_property_hash( field, args ) 
+	if index.nil? && block_given?
+	  index = yield
+	end
+	if c==1 && 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
+#	    puts "index: #{index.inspect}"
+#	    puts "bez: #{bez} ---> #{index.keys.inspect}"
+	    create_index o_class, name: bez, type: index[bez], on: [ field ]
+	  end
+	end
+
+    end
+
+
+    def create_index o_class  , name:, on: :automatic, type: :unique 
+
+      execute  transaction: false do 
+	c =  class_name o_class
+	command = if on == :automatic
+		    "create index #{c}.#{name} #{type.to_s.upcase}"
+		  elsif on.is_a? Array
+		    "create index #{name} on #{class_name(o_class)}( #{on.join(', ')}) #{type.to_s.upcase}"
+		  else 
+		    nil
+		  end
+	[	{ type: "cmd", language: 'sql', command:  command  }  ]
+      end
 
     end
 ## -----------------------------------------------------------------------------------------
@@ -458,23 +499,54 @@ todo: remove all instances of the class
 ##  create_properties
 ##  get_class_properties
 ##  delete_properties
+
 ##
 ## -----------------------------------------------------------------------------------------
+private
+def translate_property_hash  field, type: nil, linked_class: nil, **args
+	type =  type.presence ||  args[:propertyType].presence || args[:property_type]
+	linked_class = linked_class.presence || args[:linkedClass]
+	if type.present?
+	  if linked_class.nil?
+	    { field => { propertyType: type.to_s.upcase } }
+	  else
+	    { field => { propertyType: type.to_s.upcase,  linkedClass: class_name( linked_class ) } }
+	  end
+	end
+
+end
+public
 =begin
 
-creates properties which are defined as json in the provided block as
-       create_properties( classname or class ) do
-               { symbol: { propertyType: 'STRING' },
-                 con_id: { propertyType: 'INTEGER' } ,
-                details: { propertyType: 'LINK', linkedClass: 'Contracts' }
+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( con_id: { type:  :integer },
+		    details: { type:  :link, linked_class: 'Contracts' } ) do
+						 contract_idx: :notunique 
+									  end
+
+A composite index
+
+  create_properties( con_id: { type: :integer },
+		      symbol: { type: :string } ) do
+	  		{ name: 'indexname',
+			 on: [ :con_id , :details ]    # default: all specified properties
+			 type: :notunique              # default: :unique
 	        }
+		end
 
 =end
-    def create_properties o_class
+    def create_properties o_class, all_properties, &b
+
+      all_properties_in_a_hash  =  HashWithIndifferentAccess.new
+      all_properties.each{| field, args |  all_properties_in_a_hash.merge! translate_property_hash( field, args ) }
 
       begin
-	all_properties_in_a_hash =  yield
-	if all_properties_in_a_hash.is_a? Hash
+	count = if all_properties_in_a_hash.is_a?( Hash )
 	  response = @res[ property_uri(class_name(o_class)) ].post all_properties_in_a_hash.to_json
 	  if response.code == 201
 	    response.body.to_i
@@ -486,12 +558,24 @@ creates properties which are defined as json in the provided block as
 	response = JSON.parse( e.response)['errors'].pop
 	error_message  = response['content'].split(':').last
 #	if error_message ~= /Missing linked class/
-	logger.progname= 'OrientDB#CreateProperty'
+	logger.progname= 'OrientDB#CreatePropertes'
 	logger.error { "Properties in #{class_name(o_class)} were NOT created" }
 	logger.error { "Error-code #{response['code']} --> #{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 =  HashWithIndifferentAccess.new( type: :unique, on: all_properties_in_a_hash.keys ).merge index
+	    create_index o_class, index_hash # i [:name], on: index_hash[:on], type: index_hash[:type]
+	  end
+	end
+      end
+      count  # return_value
     end
 
     def delete_property o_class, field
@@ -562,19 +646,22 @@ end
 Creates an Object in the Database and returns this as ActuveOrient::Model-Instance
 =end
 
-    def create_document o_class, attributes: {}
-      attributes = yield if attributes.empty? && block_given?
-#      preallocated_attributes =  preallocate_class_properties o_class
-#      puts "preallocated_attributes: #{o_class} -->#{preallocated_attributes.inspect }"
-      post_argument = { '@class' => class_name(o_class) }.merge(attributes).to_orient
-#	puts "post_argument: #{post_argument.inspect}"
-	
-      response = @res[ document_uri ].post post_argument.to_json
-      data= JSON.parse( response.body )
-#    data = preallocated_attributes.merge data
-      ActiveOrient::Model.orientdb_class( name: data['@class']).new data
-#      o_class.new JSON.parse( response.body)
-    end
+def create_document o_class, attributes: {}
+  attributes = yield if attributes.empty? && block_given?
+  post_argument = { '@class' => class_name(o_class) }.merge(attributes).to_orient
+
+  begin
+    logger.progname = 'OrientDB#CreateDocument'
+    response = @res[ document_uri ].post post_argument.to_json
+    data= JSON.parse( response.body )
+    ActiveOrient::Model.orientdb_class( name: data['@class']).new data
+  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
 
 
     def delete_document record_id
@@ -633,7 +720,7 @@ end
       logger.progname = 'OrientDB#count_documents'
 
 	query =  OrientSupport::OrientQuery.new args
-	query.projection 'COUNT (*)'
+	query.projection << 'COUNT (*)'
 	result = get_documents raw: true, query: query 
 
 	result.first['COUNT']
@@ -824,16 +911,16 @@ structure of the provided block:
     def execute classname = 'Myquery', transaction: true  
       batch =  { transaction: transaction, operations: yield }
       unless batch[:operations].blank?
-#	puts "batch_uri: #{@res[batch_uri]}"
-#        puts "post: #{batch.to_json}"
+#       puts "post: #{batch.to_json}"
 	response = @res[ batch_uri ].post batch.to_json 
+#	puts "response: #{JSON.parse(response.body)['result'].inspect}"
 	if response.code == 200
 	  if response.body['result'].present?
 	    result= JSON.parse(response.body)['result']
 	    result.map do |x| 
 	      if x.is_a? Hash 
 		if x.has_key?('@class')
-		  ActiveOrient::Model.orientdb_class( name: x['@class']).new x
+		 ActiveOrient::Model.orientdb_class( name: x['@class']).new x
 		elsif x.has_key?( 'value' )
 		  x['value']
 		else

data/lib/support.rb

@@ -20,6 +20,8 @@ class String
 	  self
 	end
     end
+    ## this enables the universal use of an rid-string as pseudonym for a ActiveOrient::Model
+    alias :reload! from_orient
 end
 class NilClass
   def to_orient
@@ -152,9 +154,23 @@ Used by update and select
 
       def initialize  **args
 	@projection = []
-	@misc= []
+	@misc = []
+	@let  = []
+	@where = []
+	@order = []
 	args.each do | k,v|
-	self.send k, v
+	  case k
+	   when :projection
+	    @projection << v
+	   when :let
+	    @let << v
+	   when :order
+	    @order << v
+	   when :where
+	    @where << v
+	  else
+	    self.send k, v
+	  end
 	end
       end
 
@@ -171,8 +187,10 @@ Used by update and select
       end
 
       def compose
-	[ "select", projection,  from, where , subquery,  misc, order , group_by, unwind, skip ].compact.join(' ')
+	[ "select", projection_s,  from, let_s, where_s , subquery,  misc, order_s , group_by, unwind, skip ].compact.join(' ')
       end
+
+      alias :to_s  :compose
 =begin
 from can either be a Databaseclass to operate on or a Subquery providing data to query further 
 =end
@@ -188,17 +206,14 @@ from can either be a Databaseclass to operate on or a Subquery providing data to
 		      when Symbol
 			arg
 		      when OrientQuery
-			nil # don't set @database
+			arg
 		      end
-	  @from =  arg
+	  compose  # return the complete query
 	else # read from
-	  "from " << if  @from.is_a?( OrientQuery )
-		       "( #{@from.compose} )"
-	  else 
-	    @database.to_s
+	  "from " <<  @database.to_s  unless @database.nil?
 	  end
 	end
-      end
+      alias :from= :from
       def database_class= arg
 	@database =  arg if @database.present?
 	if @from.is_a? OrientQuery
@@ -225,23 +240,32 @@ where: "r > 9"                          --> where r > 9
 where: {a: 9, b: 's'}                   --> where a = 9 and b = 's'
 where:[{ a: 2} , 'b > 3',{ c: 'ufz' }]  --> where a = 2 and b > 3 and c = 'ufz'
 =end
-      def where *arg
-	@where= compose_where(*arg) unless arg.empty?
-	@where  # return_value
+      attr_accessor :where
+      def where_s
+	compose_where @where
       end
 
-      def let *arg
-#	SELECT FROM Profile
-#	LET $city = address.city
-#	WHERE $city.name like '%Saint%"' AND
-#	    ( $city.country.name = 'Italy' OR $city.country.name = 'France' )
-	puts "OrientSupport::OrientQuery@let is not implementated"
+
+      attr_accessor :let
+      def let_s
+	unless @let.empty?
+	  "let " << @let.map do |s|
+	   case s
+	  when Hash
+	    s.map{ |x,y| "$#{x} = ( #{y} )"}.join( ', ')
+	  when Array
+	    s.join(',  ')
+	  else
+	    s
+	  end
+	  end.join(', ')
+	end
       end
-      def distinct d=nil
-	if d.present?
+
+      def distinct d
 	@projection << case d
-			    when String
-			        "distinct( #{d} )"  
+			    when String, Symbol
+			        "distinct( #{d.to_s} )"  
 			    when Array
 			        "distinct( #{d.first} ) as #{d.last}"
 			    when Hash
@@ -249,13 +273,15 @@ where:[{ a: 2} , 'b > 3',{ c: 'ufz' }]  --> where a = 2 and b > 3 and c = 'ufz'
 			    else
 			      ""
 			    end 
-	end
-	@projection.join(' ,')  #return_value
+	compose  # return the hole query
       end
-      def projection s=nil
-	if s.present?
+      alias :distinct= :distinct
+
+      attr_accessor :projection
+      def projection_s
 
-	  @projection <<  case s
+	  @projection.map do | s |
+		case s
 			  when Hash
 			    s.map{ |x,y| "#{x} as #{y}"}.join( ', ')
 			  when Array
@@ -263,11 +289,11 @@ where:[{ a: 2} , 'b > 3',{ c: 'ufz' }]  --> where a = 2 and b > 3 and c = 'ufz'
 			  else
 			    s
 			  end
+	  end.join( ', ' )
 
-	end
-      	@projection.join(', ')
       end
 
+
  #     def where= w
 
  #     end
@@ -286,19 +312,25 @@ where:[{ a: 2} , 'b > 3',{ c: 'ufz' }]  --> where a = 2 and b > 3 and c = 'ufz'
 
       def skip n=nil
 	@skip= n if n.present?
-	"skip #{n}" if @skip.present?
+	"skip #{@skip}" if @skip.present?
       end
 
-      def order o=nil
-	@order_string = "order by " << case o
-	when  Hash 
-	  o.map{ |x,y| "#{x} #{y}" }.join( " " )
-	when Array
-	  o.map{ |x| "#{x} asc"}.join( " " )
+      attr_accessor :order
+
+      def order_s 
+	unless @order.empty?
+	 # the [@order] is nessesary to enable query.order= "..." oder query.order= { a: :b }  
+	  "order by " << [@order].flatten.map do | o |
+	    case o
+	    when  Hash 
+	      o.map{ |x,y| "#{x} #{y}" }.join( " " )
+	    else
+	      o.to_s
+	    end  # case
+	  end.join(', ')
 	else
-	  o.to_s
-	end if o.present?
-	@order_string
+	  ''
+	end
       end
 #	misc_string = if skip > 0 && limit > 0 
 #			" skip: #{skip} "

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active-orient
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: '0.4'
 platform: ruby
 authors:
 - Hartmut Bischoff
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-18 00:00:00.000000000 Z
+date: 2015-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.alpha
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.alpha
+        version: '2.0'
 description: Persistent ORM for OrientDB, based on ActiveModel
 email:
 - topofocus@gmail.com
@@ -83,6 +83,8 @@ files:
 - active-orient.gemspec
 - config/boot.rb
 - config/connect.yml
+- examples/books.rb
+- examples/streets.rb
 - lib/active-orient.rb
 - lib/base.rb
 - lib/base_properties.rb