active-orient 0.79 → 0.80

data/lib/model/the_record.rb

@@ -1,6 +1,9 @@
 module ModelRecord
   ############### RECORD FUNCTIONS ###############
-
+ 
+	def to_s
+		to_human
+	end
   ############# GET #############
 
   def from_orient # :nodoc:
@@ -16,7 +19,7 @@ module ModelRecord
 flag whether a property exists on the Record-level
 =end
   def has_property? property
-    attributes.keys.include? property.to_s
+    attributes.keys.include? property.to_sym
   end
 
 	def properties 
@@ -45,29 +48,38 @@ The extended representation of RID (format: *#00:00* )
   def to_or
     rid.rid? ?  rrid : "{ #{embedded} }"
   end
+	
+# returns a OrientSupport::OrientQuery 
+	def query **args
+		OrientSupport::OrientQuery.new( **{ from: self}.merge(args))
+	end
 =begin
-Query uses the current model-record  as origin of the query.
+Execute a Query using the current model-record  as origin.
 
-It sends the OrientSupport::OrientQuery directly to the database and returns an 
+It sends the OrientSupport::OrientQuery to the database and returns an 
 ActiveOrient::Model-Object or an Array of Model-Objects as result. 
 
-*Usage:* Query the Database by traversing through edges and vertices starting at a known location
+*Usage:* Query the Database by traversing through links, edges and vertices starting at a known location
 
 =end
 
-  def query query
-    
-    query.from = rrid if query.is_a? OrientSupport::OrientQuery
-    result = orientdb.execute do
-      query.to_s
-    end
-    if result.is_a? Array  
-      OrientSupport::Array.new work_on: self, work_with: result
-    else
-      result
-    end  # return value
-   end
-
+#  def execute query, delete_cash: false
+#    
+#    query.from  rrid if query.is_a?( OrientSupport::OrientQuery) && query.from.nil?
+#		ActiveOrient::Base.remove_rid( self ) if delete_cash
+#    result = orientdb.execute{ query.to_s }
+#		result = if block_given?
+#							 result.is_a?(Array)? result.map{|x| yield x } : yield(result)
+#						 else
+#							 result
+#						 end
+#    if result.is_a? Array  
+#      OrientSupport::Array.new work_on: self, work_with: result.orient_flatten
+#    else
+#      result
+#    end  # return value
+#   end
+#
 =begin
 Fires a »where-Query» to the database starting with the current model-record.
 
@@ -92,7 +104,7 @@ Returns the result-set, ie. a Query-Object which contains links to the addressed
       @metadata[:version]
     end
   end
-
+private
   def version= version  # :nodoc:
     @metadata[:version] = version
   end
@@ -101,6 +113,7 @@ Returns the result-set, ie. a Query-Object which contains links to the addressed
     @metadata[:version] += 1
   end
 
+public
 
   ############# DELETE ###########
 
@@ -108,58 +121,89 @@ Returns the result-set, ie. a Query-Object which contains links to the addressed
 #
 # It is overloaded in Vertex and Edge.
 
-def remove 
-  orientdb.delete_record self
-  ActiveOrient::Base.remove_rid self ##if is_edge? # removes the obj from the rid_store
+def delete 
+  orientdb.delete_record  self 
 end
 
-alias delete remove
 
 ########### UPDATE ############
 
 =begin
-Convient update of the dataset by calling sql-patch
+Convenient update of the dataset 
 
-Previously changed attributes are saved to the database.
+A) Using PATCH
 
-Using the optional :set argument ad-hoc attributes can be defined
+Previously changed attributes are saved to the database.
 
-    obj = ActiveOrient::Model::Contracts.first
+Using the optional »:set:« argument ad-hoc attributes can be defined
+    V.create_class :contracts
+    obj = Contracts.first
     obj.name =  'new_name'
     obj.update set: { yesterdays_event: 35 }
 updates both, the »name« and the »yesterdays_event«-properties
 
-_note:_ The keyword »set« is optional, thus
-    obj.update  yesterdays_event: 35 
-is identical
-=end
+B) Manual Modus
 
-  def update set:{}, add: nil, to: nil, **args
-    logger.progname = 'ActiveOrient::Model#Update'
+Update accepts a Block. The contents are parsed to »set«. Manual conversion of ruby-objects
+to the database-input format is necessary
 
-		if block_given?			# calling vs. a block is used internally
-			# to remove an Item from lists and sets call update(remove: true){ query }
-			set_or_remove =  args[:remove].present? ? "remove" : "set"
-			transfer_content from: 	 query( "update #{rrid} #{set_or_remove} #{ yield }  return after @this" )&.first
-		 else
-			set.merge! args
-		#	set.merge updated_at: DateTime.now
+i.e.
+	 hct is an Array of ActiveOrient::Model-records. 
+then
+	 obj.update {  "positions =  #{hct.to_or} " }
+translates to
+	 update #83:64 set positions =  [#90:18, #91:18, #92:18]   return after @this
+and returns the modified record.
+
+The manual modus accepts the keyword »remove«. 
 
-			if rid.rid?
-				transfer_content from:  db.update( self, set, version )
-				# if the updated dataset changed, drop the changes made siently
-		#		self # return value
-			else  # new record
-				@attributes.merge! set
-				save
+	 obj.update(remove: true) {  "positions =  #{hct.first.to_or} " }
+translates to
+	 update #83:64  remove  positions =  #90:18   return after @this
+
+This can be achieved by
+   obj.positions
+
+
+If the update process is not successful, nil is returned
+=end
+
+def update set: {}, remove: {}, **args
+	logger.progname = 'ActiveOrient::Model#Update'
+	#	query( kind: update,  )
+	if block_given?			# calling vs. a block is used internally
+		# to remove an Item from lists and sets call update(remove: true){ query }
+		set_or_remove =  args[:remove].present? ? "remove" : "set"
+		#transfer_content from: 	 
+		updated_record = 	db.execute{  "update #{rrid}  #{ yield }  return after $current" } &.first
+		transfer_content from: updated_record  if updated_record.present?
+	else
+		set = if remove.present?
+						{ remove: remove.merge!( args) }
+					elsif set.present?
+						 set.merge!( args) 
+					else
+						 args 
+					end
+		#	set.merge updated_at: DateTime.now
+		if rid.rid?
+			q= query.kind(:update)
+			if remove.present?
+				q.remove(remove)
+			else
+				q.set(set)
 			end
+		transfer_content from: 	q.execute(reduce: true){ |y| y[:$current].reload! }
+		else  # new record
+			 self.attributes.merge!  set
+			 save
 		end
-
-  end
+	end
+end
 
 # mocking active record  
   def update_attribute the_attribute, the_value # :nodoc:
-    update { " #{the_attribute} = #{the_value.to_or} " }
+    update the_attribute => the_value.to_or
   end
 
   def update_attributes **args    # :nodoc:
@@ -196,29 +240,14 @@ Saves the record  by calling update  or  creating the record
   end
 
 
-  def transfer_content  from:
-		# »from« can be either 
-		# a model record (in case of  create-record, get_record) or
-		# a hash containing {"@type"=>"d", "@rid"=>"#xx:yy", "@version"=>n, "@class"=>'a_classname'} 
-		# and a list of updated properties (in case of db.update). Then  update the version field and the 
-		# attributes.
-			if from.is_a? ActiveOrient::Model
-       @metadata = from.metadata
-       @attributes =  from.attributes
-			else
-				self.version =  from['@version']
-				# throw from["@..."] away and convert keys to symbols, merge that into attributes
-				@attributes.merge! Hash[ from.delete_if{|k,_| k =~ /^@/}.map{|k,v| [k.to_sym, v.from_orient]}]
-			end
-  end
   ########## CHECK PROPERTY ########
 
 =begin
   An Edge is defined
-  * when inherented from the superclass »E» (formal definition)
+  * when inherent from the superclass »E» (formal definition)
   * if it has an in- and an out property
 
-  Actually we just check the second term as we trust the constuctor to work properly
+  Actually we just check the second term as we trust the constructor to work properly
 =end
 
   def is_edge? # :nodoc:
@@ -238,6 +267,7 @@ Example:
   a.test	  # <--- attribute: 'test' --> fetch attributes[:test]
 
 Assignments are performed only in ruby-space.
+
 Automatic database-updates are deactivated for now
 =end
   def method_missing *args
@@ -262,5 +292,22 @@ Automatic database-updates are deactivated for now
   end
 #end
 
-
+#protected
+  def transfer_content  from:
+		# »from« can be either 
+		# a model record (in case of  create-record, get_record) or
+		# a hash containing {"@type"=>"d", "@rid"=>"#xx:yy", "@version"=>n, "@class"=>'a_classname'} 
+		# and a list of updated properties (in case of db.update). Then  update the version field and the 
+		# attributes.
+			return nil if from.nil?	
+			if from.is_a? ActiveOrient::Model
+       @metadata = from.metadata
+       self.attributes =  from.attributes
+			else
+				self.version =  from['@version']
+				# throw away from["@..."] and convert keys to symbols, finally merge to attributes
+				@attributes.merge! Hash[ from.delete_if{|k,_| k =~ /^@/}.map{|k,v| [k.to_sym, v.from_orient]}]
+			end
+			self  # return the modified object
+  end
 end

data/lib/model/vertex.rb

@@ -3,106 +3,178 @@ class V   < ActiveOrient::Model
  
 =begin
 specialized creation of vertices, overloads model#create
+
+  Vertex.create set: { a: 1, b: "2", c: :r }
+
+or
+
+  Vertex.create  a: 1, b: "2", c: :r 
+
+	If a record cannot be created, because an index inhibits it, the original record is
+	silently loaded instead. 
+	To avoid this behavior, call create_record and specify »silence: false«
+
 =end
-	def self.create( **keyword_arguments )
-		new_vert = db.create_vertex self, attributes: keyword_arguments
-		new_vert =  new_vert.pop if new_vert.is_a?( Array) && new_vert.size == 1
-		if new_vert.nil?
-			logger.error('Vertex'){ "Table #{ref_name} ->>  create failed:  #{keyword_arguments.inspect}" } 
-		elsif block_given?
-			yield new_vert
-		else
-			new_vert # returns the created vertex (or an array of created vertices)
-		end
+	def self.create set: {},  **attributes
+		db.create_record self, attributes: set.merge(attributes)
+	#	query.kind(:create).set( set.merge(attributes) ).execute(reduce: true)
   end
 =begin
-Vertex#delete fires a "delete vertex" command to the database.
-The where statement can be empty ( "" or {}"), then all vertices are removed 
+Vertex.delete fires a "delete vertex" command to the database.
+
+To remove all records of a class, use  »all: true« as argument
 
-The rid-cache is reseted, too
+
+The rid-cache is reset, too
 =end
-  def self.delete where: ""
-    db.execute { "delete vertex #{ref_name} #{db.compose_where(where)}" }
+  def self.delete where: {} , **args
+		if args[:all] == true 
+			where = {}
+		else
+			where.merge!(args) if where.is_a?(Hash)
+			return 0 if where.empty?
+		end
+		# query returns [{count => n }]
+		count= db.execute { "delete vertex #{ref_name} #{db.compose_where(where)}" }.first[:count] rescue 0
     reset_rid_store
+		count #  return count of affected records
   end
 
-#Present Classes (Hierarchy) 
-#---
-#- - E
-#  - - - e1
-#      - - e2
-#        - e3
-#- - V
-#  - - - v1
-#      - - v2
 
-#v.to_human
-# => "<V2[#36:0]: in: {E2=>1}, node : 4>" 
-#
-# v.detect_edges( :in, 2).to_human
-# => ["<E2: in : #<V2:0x0000000002e66228>, out : #<V1:0x0000000002ed0060>>"] 
-# v.detect_edges( :in, E1).to_human
-# => ["<E2: in : #<V2:0x0000000002e66228>, out : #<V1:0x0000000002ed0060>>"] 
-# v.detect_edges( :in, /e/).to_human
-# => ["<E2: in : #<V2:0x0000000002e66228>, out : #<V1:0x0000000002ed0060>>"] 
-#
-  def detect_edges kind = :in,  edge_name = nil # :nodoc:
-    ## returns a list of inherented classes
-    get_superclass = ->(e) do
-      n = orientdb.get_db_superclass(e)
-      n =='E' ? e : e + ',' + get_superclass[n]
-    end
-		if edge_name.nil?
-      edges(kind).map &:expand
+=begin
+Creates a new Match-Statement
+=end
+	def self.match  **args
+		OrientSupport::MatchStatement.new self,  **args
+	end
+
+=begin
+Performs a Where-Query on the vertex-class
+
+The where-cause narrows the sample to certain records. 
+
+They are returned as OrientSupport::Array
+ 
+Internally a match-query is fired. 
+
+To fire a »select from class where« query, use »Class.custom_where«.
+=end
+
+
+def self.where *attributes 
+    query_database( match(where: attributes).compile ) { | record | record[classname.pluralize.to_sym] }
+end
+
+=begin
+List edges
+
+1. call without any parameter:  list all edges present
+2. call with :in or :out     :  list any incoming or outgoing edges
+3. call with /regexp/, Class, symbol or string: restrict to this edges, including inheritence
+   If a pattern, symbol string or class is provided, the default is to list outgoing edges
+
+  :call-seq:
+  edges in_or_out, pattern 
+=end
+def edges *args
+	if args.empty?
+		detect_edges  :both
+	else
+		kind =   [:in, :out, :both, :all].detect{|x|  args.include? x }
+		if kind.present?
+			args =  args - [ kind ]
 		else
-			e_name = if edge_name.is_a?(Regexp)
-								 edge_name
-							 else
-								 Regexp.new  case  edge_name
-														 when  Class
-															 edge_name.ref_name 
-														 when String
-															 edge_name
-														 when Symbol
-															 edge_name.to_s 
-														 when Numeric
-															 edge_name.to_i.to_s
-														 end
-							 end
-	    the_edges = @metadata[:edges][kind].find_all{|y| get_superclass[y].split(',').detect{|x| x =~ e_name } }
-    
-			the_edges.map do | the_edge|
-		  candidate= attributes["#{kind.to_s}_#{the_edge}".to_sym]
-			candidate.present?  ? candidate.map( &:expand ).first  : nil 
-			end
-    end
-  end
+			kind = :both
+		end
+		detect_edges  kind, args.first
+
+	end
+end
 
 	# Lists all connected Vertices
+  # ( returns a OrientSupport::Array )
 	#
 	# The Edge-classes can be specified via Classname or a regular expression. 
 	#
-	# If a regular expression is used, the database-names are searched.
+	# If a regular expression is used, the database-names are searched and inheritance is supported.
+	#
 	def nodes in_or_out = :out, via:  nil, where: nil, expand:  false
-		if via.present?
-			edges = detect_edges( in_or_out, via )
-			detected_nodes = edges.map do |e|
-				q = OrientSupport::OrientQuery.new 
-				q.nodes in_or_out, via: e.class, where: where, expand: expand
-				query( q )
-			end.first
-		end
+			edges =  detect_edges( in_or_out, via, expand: false )
+			return [] if edges.empty?
+			q = query			# q.to_s  => "select from #0x:0x "
+			edges = nil if via.nil?
+			q.nodes in_or_out, via:  edges , where: where, expand: expand
+			detected_nodes=	q.execute{| record | record.is_a?(Hash)?  record.values.first : record  }
 	end
 
 
-  
+	# Returns a collection of all vertices passed during the traversal 
+	#
+	# Includes the start_vertex (start_at =0 by default)
+	# 
+	# If the vector should not include the start_vertex, call with `start_at:1` and increase the depth by 1
+	#
+	# fires a query
+	#   
+	#    select  from  ( traverse  outE('}#{via}').in  from #{vertex}  while $depth < #{depth}   ) 
+	#            where $depth >= #{start_at} 
+	#
+	# If » excecute: false « is specified, the traverse-statement is returned (as Orient-Query object)
+	def traverse in_or_out = :out, via: nil,  depth: 1, execute: true, start_at: 0, where: nil
+
+			edges = detect_edges( in_or_out, via, expand: false)
+			the_query = query kind: 'traverse' 
+			the_query.where where if where.present?
+			the_query.while "$depth < #{depth} " unless depth <=0
+			edges.each{ |ec| the_query.nodes in_or_out, via: ec, expand: false }
+			outer_query = OrientSupport::OrientQuery.new from: the_query, where: "$depth >= #{start_at}"
+			if execute 
+			   outer_query.execute
+				else
+		#			the_query.from self  #  complete the query by assigning self 
+					the_query            #  returns the OrientQuery  -traverse object
+				end
+		end
+
+	
+
+=begin
+Assigns another Vertex via an EdgeClass. If specified, puts attributes on the edge.
+
+Wrapper for 
+  Edge.create in: self, out: a_vertex, attributes: { some_attributes on the edge }
+
+returns the assigned vertex, thus enabling to chain vertices through
+
+    Vertex.assign() via: E , vertex: VertexClass.create()).assign( via: E, ... )
+or
+	  (1..100).each{|n| vertex = vertex.assign(via: E2, vertex: V2.create(item: n))}
+=end
+
+  def assign vertex: , via: E , attributes: {}
+
+    via.create from: self, to: vertex, set: attributes
+    
+		vertex
+  end
+
+## Optimisation (not implemented jet)
+	#
+	#         "LET $a = CREATE VERTEX VTest SET name = 'John';" +
+	#                      "CREATE EDGE ETest FROM :ParentRID TO $a;" +
+	#                      "RETURN $a;", params)
+
+
+
+
 =begin
 »in« and »out« provide the main access to edges.
-»in» is a reserved keyword. Therfore its only an alias to `in_e`.
+
+»in» is a reserved keyword. Therefor its only an alias to `in_e`.
 
 If called without a parameter, all connected edges  are retrieved.
 
-If called with a string, symbol or class, the edge-class is resolved and even inherented 
+If called with a string, symbol or class, the edge-class is resolved and even inherent 
 edges are retrieved.
 
 =end
@@ -119,60 +191,21 @@ edges are retrieved.
 =begin
 Retrieves  connected edges
 
-The basic usage is to fetch all/ incomming/ outgoing edges
+The basic usage is to fetch all/ incoming/ outgoing edges
 
-  Model-Instance.edges :in # :out | :all
+  Model-Instance.edges :in  :out | :both, :all
 
 One can filter specific edges by providing parts of the edge-name
 
-  Model-Instance.edges 'in_sector'
-  Model-Instance.edges /sector/
-
-The method returns an array of rid's.
-
-Example:
-
-  Industry.first.attributes.keys
-   => ["in_sector_classification", "k", "name", "created_at", "updated_at"]  # edge--> in ...
+  Model-Instance.edges /sector/, :in
+  Model-Instance.edges :out, /sector/
+  Model-Instance.edges  /sector/
+  Model-Instance.edges  :in
 
-  Industry.first.edges :out
-    => []
 
-  Industry.first.edges :in
-  => ["#61:0", "#61:9", "#61:21", "#61:33", "#61:39", "#61:93", "#61:120", "#61:150", "#61:240", "#61:252", "#61:264", "#61:279", "#61:303", "#61:339" ...]
-  
 
+The method returns an array of  expands edges.
 
-To fetch the associated records use the ActiveOrient::Model.autoload_object method
-  
-  ActiveOrient::Model.autoload_object Industry.first.edges( :in).first	
-  # or
-  Industry.autoload_object Industry.first.edges( /sector/ ).first
-   => #<SectorClassification:0x00000002daad20 @metadata={"type"=>"d", "class"=>"sector_classification", "version"=>1, "fieldTypes"=>"out=x,in=x", "cluster"=>61, "record"=>0},(...)
-
-=end
-  
-  def edges kind=:all  # :all, :in, :out 
-    expression = case kind
-		 when :all
-		   /^in|^out/ 
-		 when :in
-		   /^in/ 
-		 when :out
-		   /^out/ 
-		 when String
-		   /#{kind}/
-		 when Regexp
-		   kind
-		 else
-		   return  []
-		 end
-
-    edges = attributes.keys.find_all{ |x| x =~  expression }
-    edges.map{|x| attributes[x]}.flatten
-  end
-
-=begin
 »in_edges« and »out_edges« are shortcuts to »edges :in« and »edges :out«
 
 Its easy to expand the result:
@@ -191,7 +224,7 @@ returns all edges. The parameter (:out) is not recognized, because out is alread
 
 this
   tg.out( :ohlc).first.out.edges( :out)
-is a walkaround, but using in_- and out_edges is more  elegant.
+is a workaround, but using in_- and out_edges is more  elegant.
 =end
   def in_edges
     edges :in
@@ -204,9 +237,9 @@ is a walkaround, but using in_- and out_edges is more  elegant.
  #   db.delete_vertex self
 #	end
 =begin
-Human readable represantation of Vertices
+Human readable representation of Vertices
 
-Format: < Classname : Edges, Attributes >
+Format: < Classname: Edges, Attributes >
 =end
 	def to_human
 		count_and_display_classes = ->(array){array.map(&:class)&.group_by(&:itself)&.transform_values(&:count)} 
@@ -223,7 +256,7 @@ Format: < Classname : Edges, Attributes >
 		"<#{self.class.to_s.demodulize}[#{rid}]: " + in_and_out  + content_attributes.map do |attr, value|
 			v= case value
 				 when ActiveOrient::Model
-					 "< #{self.class.to_s.demodulize} : #{value.rid} >"
+					 "< #{self.class.to_s.demodulize}: #{value.rid} >"
 				 when OrientSupport::Array
 					 value.to_s
 #					 value.rrid #.to_human #.map(&:to_human).join("::")
@@ -233,4 +266,106 @@ Format: < Classname : Edges, Attributes >
 			"%s : %s" % [ attr, v]  unless v.nil?
 		end.compact.sort.join(', ') + ">".gsub('"' , ' ')
 	end
+
+
+
+
+
+#protected
+#Present Classes (Hierarchy) 
+#---
+#- - E
+#  - - - e1
+#      - - e2
+#        - e3
+#- - V
+#  - - - v1
+#      - - v2
+
+# v.to_human
+# => "<V2[#36:0]: in: {E2=>1}, node : 4>" 
+#
+# v.detect_edges( :in, 2).to_human
+# => ["<E2: in : #<V2:0x0000000002e66228>, out : #<V1:0x0000000002ed0060>>"] 
+# v.detect_edges( :in, E1).to_human
+# => ["<E2: in : #<V2:0x0000000002e66228>, out : #<V1:0x0000000002ed0060>>"] 
+# v.detect_edges( :in, /e/).to_human
+# => ["<E2: in : #<V2:0x0000000002e66228>, out : #<V1:0x0000000002ed0060>>"] 
+#
+#
+#  returns a OrientSupport::Array
+	def detect_edges kind = :in,  edge_name = nil, expand: true  #:nodoc:
+		## returns a list of inherent DD classes
+		get_superclass = ->(e) do
+			if [nil,"", "e", "E", E, :e, :E ].include?(e)
+				"E"
+			else
+				n = orientdb.get_db_superclass(e)
+				n =='E' ? e : e + ',' + get_superclass[n]
+			end
+		end
+	
+		expression = case kind
+								 when :in
+									 /^in_/ 
+								 when :out
+									 /^out_/
+								 else
+									 /^in_|^out_/ 
+								 end
+
+		extract_database_class = ->(c){ y =  c.to_s.gsub(expression, ''); y.empty? ? "E": y   }
+		result, the_edges  = []   #  we have to declare result prior to its usage in the loop to make
+					  		              #  its content robust 
+		attempt =  0
+		loop do
+			# get a set of available edge-names 
+			# in_{abc} and out_{abc}
+			# with "out_" and "in_" as placeholder for E itself
+			# populate result in case no further action is required
+			result = the_edges = attributes.keys.find_all{ |x|  x =~  expression }
+			# eager reloading
+			if result.empty? && attempt.zero?
+				reload!
+				attempt = 1
+			else
+				break
+			end
+		end
+
+		if edge_name.present?
+			# if a class is provided, match for the ref_name only
+			if edge_name.is_a?(Class) 
+				result = [ the_edges.detect{ |x| edge_name.ref_name == extract_database_class[x] } ]
+			else
+				e_name = if edge_name.is_a?(Regexp)
+									 edge_name
+								 else
+									 Regexp.new  case  edge_name
+																			 #				 when  Class
+																			 #					 edge_name.ref_name 
+																		 when String
+																			 edge_name
+																		 when Symbol
+																			 edge_name.to_s 
+																		 when Numeric
+																			 edge_name.to_i.to_s
+																		 end
+								end	
+				result = the_edges.find_all do |x|
+					get_superclass[extract_database_class[x] ].split(',').detect{|x| x =~ e_name } 
+				end
+			end
+		end
+		# if expand = false , return the orientdb database name of the edges
+		#  this is used by  Vertex#nodes 
+		#  it avoids communications with the database prior to submitting the nodes-query
+		# if expand = true (default) load the edges instead
+		if expand
+			OrientSupport::Array.new work_on: self, 
+				work_with: 	result.compact.map{|x| attributes[x]}.map(&:expand).orient_flatten
+		else
+			result.map{|x|	extract_database_class[x] }
+		end
+	end
 end