active-orient 0.6 → 0.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c3fb207d23e5c1cd30e95105075370967fb4a6b
-  data.tar.gz: 6f606ff9a666368ddcaa51dd0e3ca7f7edf3bfa2
+  metadata.gz: ed8d14a983f8e3d067830ef41396d2cef289b46b
+  data.tar.gz: f848a337d6b4cd07e591d902402547f1f225b01f
 SHA512:
-  metadata.gz: 371a9c4ad68cad3f4efc701c3965e1f946bce6f610b4ea7245f3f168a6417185dc7829395387a07f97e55f92c02829a7e72999f824ffffff92e99f17090e1113
-  data.tar.gz: 2f4c7e0a6a74a34c5f605ae6b9ee094eb4c2ff51827c1beb5d77be04caceba6c7ed2149edd093be0ee9b9004afa6bdc4fdc203d4c1e5122d648c7b87aebfb961
+  metadata.gz: 4616d3587af1744fc6047b9aab929ae60911248029c310329c27cc36e3a545ed33c77fbe3d1f90b1b29346bf779dbe643497293d79618d06b3f6f950b6b6c464
+  data.tar.gz: 56a0f4ead290409aae2fde9e7af73d546cab19b3762d5d64d6bf4215ea23d2f71025c716a959f746a180125cb4c12c2e9cac492efd57ef3e2148c8a517e30a80

data/.gitignore

@@ -7,4 +7,3 @@
 /pkg/
 /spec/reports/
 /tmp/
-*~

data/Gemfile

@@ -1,21 +1,15 @@
 source "https://rubygems.org"
 gemspec
-gem 'activesupport' # ,  "~>4.2"
-gem 'activemodel' #,   "~>4.2"
-#gem 'activemodel-serializers-xml'
-gem 'rest-client'  , :git => 'git://github.com/rest-client/rest-client.git'
+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'
-gem 'orientdb' , :path => '/home/topo/orientdb-jruby' , :platforms => :jruby
-#gem 'orientdb' , :git => 'git://github.com/topofocus/orientdb-jruby.git', :branch => '2.1.2', :platforms => :jruby
 group :development, :test do
-	gem "awesome_print"
 	gem "rspec"
-	gem 'rspec-legacy_formatters'
 	gem 'rspec-its'
 	gem 'rspec-collection_matchers'
 	gem 'rspec-context-private'
-	gem 'guard-jruby-rspec', :platforms => :jruby, :git => 'git://github.com/jkutner/guard-jruby-rspec.git'
-	gem 'guard'#, :platforms => :ruby
+	gem 'guard'
 	gem 'guard-rspec'
 ##	gem 'database_cleaner'
 	gem 'rb-inotify'

data/Guardfile

@@ -1,6 +1,7 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
-def fire
+
+guard :rspec, cmd: "bundle exec rspec" do
   require "ostruct"
 
   # Generic Ruby apps
@@ -11,19 +12,10 @@ def fire
 
 
   watch(%r{^spec/.+_spec\.rb$})
-#  watch(%r{^spec/usecase/(.+)\.rb$})
+  watch(%r{^spec/usecase/(.+).rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-#  watch(%r{^examples/time_graph/spec/(.+)_spec\.rb$}) 
-  watch('examples/time_graph/spec/create_time_spec.rb') 
   watch('spec/spec_helper.rb')  { "spec" }
 
-  watch(%r{^spec/support/(.+)\.rb$})  { "spec" }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
 end
 
-
-interactor :simple
-if RUBY_PLATFORM == 'java' 
-guard( 'jruby-rspec') {fire}  #', :spec_paths => ["spec"]
-else
-guard( :rspec, cmd: "bundle exec rspec") { fire }
-end

data/README.md

@@ -2,387 +2,324 @@
 Use OrientDB to persistently store dynamic Ruby-Objects and use database queries to manage even very large
 datasets.
 
-#### Other Documents
-- [Experiments with Joins / Linkmaps ](./linkmap.md)
+The Package ist tested with Ruby 2.2.1 and Orientdb 2.1.
 
-- [Experiments with the GratefulDeadConcerts Sample Database](./gratefuldeadconcerts.md)
 
-- [Namespace Support](./namespace.md)
+To start you need a ruby 2.x Installation and a working OrientDB-Instance.  
+Install the Gem the usual way
 
-- [TimeGraph Implementation](examples/time_graph.md)
+For a quick start, go to the home directory of the package and start an irb-session
 
-- [Rails 5-Integration](./rails.md)
-
-You need a ruby 2.3, 2.4  or a jruby 9.1x Installation and a working OrientDB-Instance (Version 2.2 prefered).
-The jruby-part is experimental.
-
-### Quick Start
-
- - clone the project, 
- - run bundle install & bundle update, 
- - update config/connect.yml, 
- - create the documentation by calling »rdoc«
- - start an irb-session by calling  
-```
-cd bin
-./active-orient-console test   # or d)develpoment, p)roduction environment as defined in config/connect.yml
+```ruby
+  require 'bundler/setup'
+  require 'active-orient'
 ```
 
-«ORD» or «DB» is the Database-Instance itself. If the Database noticed is not present, it is created on startup.
-A simple SQL-Query is submitted by providing a Block to »execute«
- ```ruby
- result =  ORD.execute { "select * from Stock" } 
- ```
-Obviously, the class »Stock« has to exist. 
-Let's create some classes
-
- ```ruby
-    ORD.create_class        'ClassDocumentName'  # creates or opens a basic document-class
-    ORD.create_vertex_class 'ClassVertexName'  # creates or opens a vertex-class
-    ORD.create_edge_class   'ClassEdgeName'  # creates or opens an edge-class, providing bidirectional links between documents
-    {Classname}.delete_class			 # removes the class in the database and destroys the ruby-object
- ```
+First, the Database-Server has to be specified. Then we can connect to a database.
+Assuming, the server is located on localhost, we just define »default-server«
+```ruby
+   ActiveOrient::OrientDB.default_server= { user: 'your user', password: 'your password' }
 
-Classnames appear unchanged as Database-Classes. Strings and Symbols are accepted. Depending on the namespace choosen in 'config/config.yml' Model-Classes are allocated and linked to database-classes. For simplicity, here we omit any namespace ( :namespace: :object in config.yml). Thus the Model-Obects are accessible directly.
 
+  r = ActiveOrient::OrientDB.new  database: 'First'
+   => I, [2015-08-18T09:49:18.858758 #88831]  INFO -- OrientDB#Connect: Connected to database First
+   => #<ActiveOrient::OrientDB:0x000000048d0488 @res=#<RestClient::Resource:0x00000004927288 
+       @url="http://localhost:2480", @block=nil, 
+       @options={:user=>"xx", :password=>"***"}>, @database="First", @classes=[]> 
+```
 
-**Naming-Convention:** The name given in the »create-class«-Statement becomes the Database-Classname. 
-In Ruby-Space its Camelized, ie:  ORD.create_class(:hut_ab) generates a Ruby-Class »HutAb«. 
+»r« is the Database-Instance itself.  Obviously the database is  empty.
 
-This can be customized in the "naming_convention"-class-method, which has to be defined in 'config/boot.rb'. The naming_convention changes the ruby-view to the classes. The Database-Class-Name is derived from the argument to #CreateClass, ORD.create_class('HANDS_UP') creates a database-class "HANDS_UP' and a Ruby-Class "HandsUp".
 
-ActiveOrient::Model's can be customized through methods defined in the model-directory. These methods are
-loaded automatically afert executing #CreateClass (and through the preallocation process). Further details in the Examples-Section.
+Let's create some classes 
 
-#### CRUD
-The CRUD-Process (create, read = query, update and remove) is performed as
-```ruby	
-    ORD.create_class :M
-    M.create name: 'Hugo', age: 46, interests: [ 'swimming', 'biking', 'reading' ]
-    # or
-    new_record =  M.new  age: 46, interests: [ 'swimming', 'biking', 'reading' ]
-    new_record.save   # alternative: new_record.update
-    ##
-    hugo = M.where( name: 'Hugo' ).first
-    hugo.update set: { :father => M.create( name: "Volker", age: 76 ) } # we create an internal link
-    hugo.father.name	# --> volker
-    M.remove hugo 
-    M.delete_class	# removes the class from OrientDB and deletes the ruby-object-definition
- ```
- 
-#### Inherence
+ ```ruby
+    M = r.open_class          'classname'  # 
+    M = r.create_class        'classname'  # creates or opens a basic document-class
+    M = r.create_vertex_class 'classname'  # creates or opens a vertex-class 
+    M = r.create_edge_class   'classname'  # creates or opens an edge-class, providing bidirectional links between documents
 
-Create a Tree of Objects with create_classes
-```ruby
-  ORD.create_classes  sector: [ :industry, :category, :subcategory ] 
-  => {Sector=>[Industry, Category, Subcategory]}
-  Industry.create name: 'Communications'   #--->   Create an Industry-Record with the attribute "name"
-  Sector.where  name: 'Communications'	   #--->   an Array with the Industry-Object
-  => [#<Industry:0x0000000225e098 @metadata= (...) ] 
+    r.delete_class   M                   # universal removal-of-the-class-method
  ```
- ***notice*** to create inherent Vertices use ORD.create_classes( sector: [ :industry, :category, :subcategory ]){ :V  } 
 
-#### Preallocation of Model-Classes
-All database-classes are preallocated after connecting to the database. Thus you can use Model-Classes from the start.
 
-If the "rid" is known, any Object can be retrieved and correctly allocated by
-```ruby
-  the_object =  V.autoload_object "xx:yy" # or "#xx:yy"
-  --->  {ActiveOrient::Model} Object 
-```
-The database-class  «V» is present in any case. Any model-class can be used, even the parent »ActiveOrient::Model«
+»M« is the ActiveOrient::Model-Class itself, a constant pointing to the class-definition of the ruby-class.
+Its a shortcut for »ActiveOrient::Model::{Classname} and is reused if defined elsewhere.
 
-#### Properties
-The schemaless mode has many limitations. ActiveOrient offers a Ruby way to define Properties and Indexes
+If a schema is used, properties can be created and retrieved as well
+ ```ruby
+  r.create_properties( M ) do
+     {	symbol: { propertyType: 'STRING' },
+		con_id: { propertyType: 'INTEGER' },
+       	details: { propertyType: 'LINK', linkedClass: 'Contracts' }
+      }
 
+  r.get_class_properties  M 
+ ```
+ or
  ```ruby
- ORD.create_class  :M, :item
- M.create_property :symbol 			# the default-case: type: :string, no index
- M.create_property :con_id,   type: :integer
- M.create_property :details,  type: :link, other_class: 'Contracts'
- M.create_property :items,    type: :linklist, :linklist: Item
- M.create_property :name,    index: :unique	# or  M.create_property( 'name' ){ :unique }
+ M.create_property  'symbol'
+ M.create_property  'con_id', type: 'integer'
+ M.create_property  'details', type: 'link', other_class: 'Contracts'
  ```
 
-(Experimental) You can put restrictions on your properties with the command "alter_property":
-
+#### Active Model interface
+ 
+Every OrientDB-Database-Class is mirrord as Ruby-Class. The Class itself is defined  by
 ```ruby
-  M.alter_property property: "value", attribute: "MIN", alteration: 0
-  M.alter_property property: "value", attribute: "MAX", alteration: 23
+  M =  r.create_class 'classname' 
+  M =  r.create_class { superclass_name:  'classname'  }
+  Vertex =  r.create_vertex_class 'classname' 
+  Edge   =  r.create_edge_class   'classname' 
 ```
+and is of TYPE ActiveOrient::Model::{classname}
 
-#### Active Model interface
-
-As for ActiveRecord-Tables, the Model-class itself provides methods to inspect and filter datasets form the database.
+As for ActiveRecord-Tables, the Class itself provides methods to inspect and to filter datasets form the database.
 
 ```ruby
   M.all   
   M.first
-  M.last  	# notice: last does not work in orientdb version 2.2, because the sorting algorithm for rid's is damaged
-  M.all.last    # or M.where( ... ).last  walkaround for  Orientdb V 2.2
-  M.where town: 'Berlin'
+  M.last
+```
+returns an Array containing all Documents/Edges of the Class; the first and the last Record.
+```ruby
+  M.where  town: 'Berlin'
+```
+performs a query on the class and returns the result as Array
 
+```ruby
   M.count where: { town: 'Berlin' }
 ```
-»count« gets the number of datasets fulfilling the search-criteria. Any parameter defining a valid SQL-Query in Orientdb can be provided to the »count«, »where«, »first« and »last«-method.
+gets the number of datasets fullfilling the search-criteria. Any parameter defining a valid
+SQL-Query in Orientdb can be provided to the count, where, first and last-method.
 
-A »normal« Query is submitted via
+A »normal« Query is submitted via 
 ```ruby
-  M.get_records projection: { projection-parameter },
-		  distinct: { some parameters },
-		  where: { where-parameter },
-		  order: { sorting-parameters },
-		  group_by: { one grouping-parameter},
-		  unwind:  ,
-		  skip:    ,
-		  limit:  
+  M.get_documents projection: { projection-parameter }
+		  distinct: { some parameters }
+		  where: { where-parameter }
+		  order: { sorting-parameters }
+		  group_by: { one grouping-parameter}
+		  unwind:
+		  skip:
+		  limit:
 
 #  or
- query = OrientSupport::OrientQuery.new {paramter}  
- M.query_database query
+ query = OrientSupport::OrientQuery.new {paramter}
+ M.get_documents query: query
 
 ```
 
-To update several records, a class-method »update_all« is defined.
-```ruby
-  M.update_all connected: false   	# add a property »connected» to each record
-  M.update_all set:{ connected: true },  where: "symbol containsText 'S'" 
-```
+Basic graph-support:
+
 
-Graph-support:
 
 ```ruby
-  ORD.create_vertex_class :the_vertex
-  ORD.create_edge_class :the_edge
-  vertex_1 = TheVertex.create  color: "blue"
-  vertex_2 = TheVertex.create  flower: "rose"
-  TheEdge.create_edge attributes: {:birthday => Date.today }, from: vertex_1, to: vertex_2
+  vertex_1 = Vertex.create  color: "blue"
+  vertex_2 = Vertex.create  flower: "rose"
+  Edge.create_edge attributes: { :birthday => Date.today }, from: vertex_1, to: vertex_2
 ```
-It connects the vertexes and assigns the attributes to the edge.
+connects the vertices and assigns the attributes to the edge
 
-To query a graph,  SQL-like-Queries and Match-statements can be used (see below). 
 
+#### Links
 
-#### Links and LinkLists
+A record in a database-class is defined by a »rid«. Every Model-Object comes with a handy »link«-method.
 
-A record in a database-class is defined by a »rid«. If this is stored in a class, a link is set.
-In OrientDB links are used to realize unidirectional 1:1 and 1:n relationships.
+In OrientDB links are used to realise unidirectional  1:1 and 1:n relationships.
 
-ActiveOrient autoloads Model-objects when they are accessed. Example:
-If an Object is stored in Cluster 30 and id 2, then "#30:2" fully qualifies the ActiveOrient::Model object and sets the 
-link if stored somewhere.
+ActiveOrient autoloads Model-objects when they are accessed. As a consequence, 
+if an Object is stored in Cluster 30 and id 2, then "#30:2" fully qualifies the ActiveOrient::Model object.
 
 ```ruby
-  ORD.create_class 'test_link'
-  ORD.create_class 'test_base'
+  TestLinks = r.create_class 'Test_link_class'
+  TestBase = r.create_class 'Test_base_class'
 
-  link_document =  TestLink.create  att: 'one attribute'
-  base_document =  TestBase.create  base: 'my_base', single_link: link_document
+  link_document =  TestLinks.create  att: 'one attribute' 
+  base_document =  TestBase.create  base: 'my_base', single_link: link_document 
 ```
-base_document.single_link just contains the rid. When accessed, the ActiveOrient::Model::Testlinkclass-object is autoloaded and
-
+base_document.single_link just contains the rid. When accessed, the ActiveOrient::Model::Testlinkclass-object is autoloaded and 
 ``` ruby
    base_document.single_link.att
 ```
-reads the stored content of link_document.
+reads the stored content of link_document. 
 
-To store a list of links to other Database-Objects, a simple Array is allocated
+To store a list of links to other Database-Objects a simple Array is allocated
 ``` ruby
   # predefined linkmap-properties
-  TestLink.create_property  :links,  type: :linklist, linkedClass: :test_links 
-  base_document =  TestBase.create links: []  
-  (0 .. 20).each{|y| base_document.links << TestLink.create( nr: y )}
-  
+  base_document =  TestBase.create links: []
+  ( 0 .. 20 ).each{ |y|  base_document.links << TestLinks.create  nr: y  }
+  end
   #or in schemaless-mode
-  base_document = TestBase.create links: (0..20).map{|y| TestLink.create nr: y}
-  base_document.update
+  base_document =  TestBase.create links: (0..20).map{|y|  TestLinks.create  nr: y  }
+
+
 ```
-base_document.links behaves like a ruby-array.
+base_document.links behaves like a ruby-array. 
 
 If you got an undirectional graph
 
    a --> b ---> c --> d
 
-the graph elements can be explored by joining the objects (a[6].b[5].c[9].d)
-
-Refer to the "Time-Graph"-Example for an Implementation of an bidirectional Graph with the same Interface
+the graphelements can be explored by joining the objects ( a.b.c.d ), or (a.b[5].c[9].d )
 
 #### Edges
-Edges provide bidirectional Links. They are easily handled
+
+Edges are easily handled
 ```ruby
-  ORD.create_vertex_class :the_vertex 	# -->  TheVertex
-  ORD.create_edge_class  :the_edge      # -->  TheEdge
+  Vertex = r.create_vertex_class 'd1'
+  Eedge = r.create_edge_class   'e1'
 
-  start = TheVertex.create something: 'nice'
-  the_end  = TheVertex.create something: 'not_nice'
-  the_edge = TheEdge.create attributes: {transform_to: 'very bad'},
+  start =  Vertex.create  something: 'nice' 
+  the_end   =  Vertex.create  something: 'not_nice' 
+  the_edge = Edge.create_edge  attributes:  { transform_to: 'very bad' },
 			       from: start,
 			       to: the_end
+ 
+  (...)
+  the_edge.delete
 ```
-Edges are connected to vertices by »in« and »out«-Methods.
-Inherence is supported.
 
-i.e.
-```ruby
-  ORD.create_class( top_edge ) { THE_EDGE }
-  ORD.create_class( on_top_edge ) { TOP_EDGE }
+There is a basic support for traversals throught a graph.
+The Edges are accessed  by their names (downcase).
 
-  ON_TOP_Edge.create  from: start, to: the_end
-  start.reload!
-  start.out :the_edge 
-  => [#<TOP_EDGE:0x00000001d92f28 @metadata= ... ]
-```
-
-Edge-links are displayed and retrieved by
 ```ruby
-  start.edges	  # :in | :out | :all 
-   => ["#73:0"] 
-  
-  start.edges(:out).map &:from_orient
-  => [#<TOP_EDGE:0x00000001d92f28 @metadata= ... ]
-
+  start.e1[0]
+  --> #<ActiveOrient::Model::E1:0x000000041e4e30 
+	@metadata={"type"=>"d", "class"=>"E1", "version"=>60, "fieldTypes"=>"out=x,in=x", 
+		   "cluster"=>16, "record"=>43}, 
+        @attributes={"out"=>"#31:23", "in"=>"#31:15", "transform_to"=>"very bad" }>
 ```
-
-
-The create-Method od Edge-Classes takes a block. Then all statements are transmitted in batch-mode.
-Assume, Vertex1 and Vertex2 are Vertex-Classes and TheEdge is an Edge-Class, then
+The Attributes "in" and "out" can be used to move across the graph
 ```ruby
-  record1 = (1 .. 100).map{|y| Vertex1.create testentry: y  }
-  record2 = (:a .. :z).map{|y| Vertex2.create testentry: y  }
-  edges = TheEdge.create attributes: { study: 'Experiment1'} do  | attributes |
-   # map returns an array, which is further processed by #create_edge 
-    ('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  
+   start.e1[0].out.something 
+   ---> "not_nice
+   start.e1[0].in.something 
+   ---> "nice
 ```
-connects the vertices and provides a variable "key" and a common "study" attribute to each edge.
-
-
 #### Queries
+Contrary to traditional SQL-based Databases OrientDB handles  subqueries very efficient. 
+In addition, OrientDB supports precompiled statements (let-Blocks).
 
-Contrary to traditional SQL-based Databases OrientDB handles sub-queries very efficiently. In addition, OrientDB supports precompiled statements (let-Blocks).
-
-ActiveOrient is equipped with a simple QueryGenerator: ActiveSupport::OrientQuery.
-It works in two ways: a comprehensive and a subsequent one
-
+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     # If a constant is used, then the correspending
-		      # ActiveOrient::Model-class is refered
+  q.from = Vertex  
   q.where << a: 2
   q.where << 'b > 3 '
   q.distinct = :profession
-  q.order = {:name => :asc}
+  q.order =  { :name => :asc }
 
 ```
 is equivalent to
-
 ```ruby
-  q =  OrientSupport::OrientQuery.new from:  Vertex ,
+  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.
 
-Both eayss can be mixed.
-
-If sub-queries are necessary, they can be introduced as OrientSupport::OrientQuery or as »let-block«.
-
+If subqueries are nessesary, they can be introduced as OrientSupport::OrientQuery or as »let-block«.
 ```ruby
-  OQ = OrientSupport::OrientQuery
-  q = OQ.new from: 'ModelQuery'
+  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'
+  => select from ModelQuery let $city = adress.city where $city.country.name = 'Italy' OR $city.country.name = 'France' 
 ```
-
 or
-
 ```ruby
-  q =  OQ.new
-  q.let << {a: OQ.new( from: '#5:0' ) }
-  q.let << {b: OQ.new( from: '#5:1' ) }
+  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)
+  q.to_s
+  => select expand( $c ) let $a = ( select from #5:0 ), $b = ( select from #5:1 ), $c= UNIONALL($a,$b)
 ```
 
-or
 
-```ruby
-  last_12_open_interest_records = OQ.new from: OpenInterest, 
-					order: { fetch_date: :desc } , limit: 12
-  bunch_of_contracts = OQ.new from: last_12_open_interest_records, 
-			      projection: 'expand( contracts )'
-  distinct_contracts = OQ.new from: bunch_of_contracts, 
-			      projection: 'expand( distinct(@rid) )'
 
-  distinct_contracts.to_s
-   => "select expand( distinct(@rid) ) from ( select expand( contracts ) from ( select  from open_interest order by fetch_date desc limit 12 ) ) "
 
-  cq = ORD.get_documents query: distinct_contracts
-```
-this executes the query and returns the adressed rid's, which are eventually retrieved from the rid-cache.
-#### Match
+#### Execute SQL-Commands
+Sql-commands can be executed as batch
 
-A Match-Query starts at the given ActiveOrient::Model-Class. The where-cause narrows the sample to certain 
-records. In the simplest version this can be returned:
+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.
+
+```ruby
+   ach = ActiveOrient::Query.new
+    
+   ach.queries << 'create class Contracts ABSTRACT'
+   ach.queries << 'create property Contracts.subcategory link'
+   ach.queries << 'create property Contracts.details link'
+   ach.queries << 'create class Stocks extends Contracts'
+   ach.queries << 'create class Futures extends Contracts'
+   result = ach.execute_queries transaction: false
+   
+   
+
+```
+  queries the database as demonstrated above. In addition, the generated query itself is added to the »queries«-Stack and the result can be found in sample_query.records.
   
+This feature can be used as a substitute for simple functions
+
 ```ruby
-  ORD.create_class :Industry
-  Industry.match where:{ name: "Communications" }
-  => #<Query:0x00000004309608 @metadata={"type"=>"d", "class"=>nil, "version"=>0, "fieldTypes"=>"Industries=x"}, @attributes={"Industries"=>"#21:1", (...)}>
+ roq = ActiveOrient::Query.new
+ roq.queries =["select name, categories.subcategories.contracts from Industries  where name containstext     …'ial'"]
+ roq.execute_queries.each{|x|  puts x.name, x.categories.inspect }
+ --> Basic Materials 	[["#21:1"]]
+ --> Financial  	[["#21:2"]]
+ --> Industrial 	[["#23:0", "#23:1"]]
 ```
 
-The attributes are the return-Values of the Match-Query. Unless otherwise noted, the pluralized Model-Classname is used as attribute in the result-set. *Note* that the Match statement returns a »Query«-record. Its up to the usere, to transform the attributes to Model-Objects. This is done by the »to_orient« directive, ie. »xx.Industries.to_orient «
+OrientDB supports the execution of SQL-Batch-Commands. 
+( http://orientdb.com/docs/2.0/orientdb.wiki/SQL-batch.html )
+This is supported simply by using a Array as Argument for ActiveOrient::Query.queries
 
+Therefor complex queries can be simplified using database-variables 
 ```ruby
-  Industry.match where name: "Communications" 
-  ## is equal to
-  Industry.match( where: { name: 'Communications' }).first.Industries
+   ach = ActiveOrient::Query.new
+   ach.queries << [ "select expand( contracts )  from Openinterest"
+	            "let con = select expand( contracts )  from Openinterest; ",
+		    "...", ... ]
+   result = ach.execute_queries 
 ```
-The Match-Query uses this result-set as start for subsequent queries on connected records.
-If a linear graph: Industry <- Category <- Subcategory <- Stock  is build, Subcategories can 
-accessed starting at Industry defining
 
+The contract-documents are accessible with 
 ```ruby
-  var = Industry.match( where: { name: 'Communications'}) do | query |
-    query.connect :in, count: 2, as: 'Subcategories'
-    puts query.to_s  # print the query prior sending it to the database
-    query            # important: block has to return the query 
-  end
-  => MATCH {class: Industry, as: Industries} <-- {} <-- { as: Subcategories }  RETURN Industries, Subcategories
+  r.get_document '21:1'
+  --><Stocks: con_id: 77680640 currency: EUR details: #18:1 exchange: SMART local_symbol: BAS 
+     primary_exchange: IBIS subcategory: #14:1 symbol: BAS>
 ```
+or
+```ruby
+    my_query = ActiveOrient::Query.new
+    ['Contracts', 'Industries', 'Categories', 'Subcategories'].each do |table|
+        my_query.queries = [ "select count(*) from #{table}"]
+ 
+        count = my_query.execute_queries
+        # count=> [#<ActiveOrient::Model::Myquery:0x00000003b317c8 
+        #		@metadata={"type"=>"d", "class"=>nil, "version"=>0, "fieldTypes"=>"count=l"},
+        #		@attributes={"count"=>4 } ] --> an Array with one Element, therefor count.pop 
+        puts "Table #{table} \t #{count.pop.count} Datasets "
+    end
+    -->Table Contracts 	 	56 Datasets 
+    -->Table Industries 	 8 Datasets 
+    -->Table Categories 	22 Datasets 
+    -->Table Subcategories 	35 Datasets 
 
-The result-set has two attributes: Industries and Subcategories, pointing to the filtered datasets.
-
-By using subsequent »connect« and »statement« method-calls even complex Match-Queries can be constructed. 
-
-
-#### Other Documents
-- [Experiments with Joins / Linkmaps ](./linkmap.md)
-
-- [Experiment with the GratefulDeadConcerts Sample Database](./gratefuldeadconcerts.md)
-
-- [Namespace Support](./namespace.md)
-
-- [TimeGraph Implementation](examples/time_graph.md)
+```
 
+Note that the fetched Object is of type »Stocks« (ActiveOrient::Model::Stocks).
 
-  deactivated behavior: to turn it on, some work on base.rb is required
-``` 
-  start.the_edge  # --> Array of "TheEdge"-instances connected to the vertex
-  start.the_edge.where transform_to: 'good'     # ->  empty array
-  start.the_edge.where transform_to: 'very bad' #-->  previously connectd edge
-  start.something     # 'nice'
-  end.something	      # 'not_nice'
-  start.the_edge.where( transform_to: 'very bad').in.something  # => ["not_nice"] 
-  (...)
-  the_edge.delete # To delete the edge
-```
+The ActiveOrient-API documentation can be found here: https://github.com/orientechnologies/orientdb-docs/wiki/OrientDB-ActiveOrient
+and the ActiveModel-documentation is here: http://www.rubydoc.info/gems/activemodel
+ 
+ 
+