arcadedb 0.3.1 → 0.3.3

data/bin/+

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+## loads the active-orient environment 
+## and starts an interactive shell
+##
+## Parameter:  
+##	       production (p)
+##	       development (d)  [default]
+##	       test (t)
+require 'bundler/setup'
+require 'yaml'
+require 'logger'
+require 'pastel'
+require 'terminal-table'
+require 'arcade'
+#begin
+
+module CoreExtensions
+
+  module Hash
+    module TablePresenter
+      def table_header
+          keys
+      end
+      def table_row
+          values
+      end
+    end
+  end
+
+  module Array
+    module TablePresenter
+      def as_table(&b)
+        the_table_header = first.table_header(&b)
+        the_table_rows = map &:table_row
+        Terminal::Table.new headings: the_table_header, rows: the_table_rows , style: { border: :unicode  }
+      end
+    end
+  end
+end
+
+Array.include CoreExtensions::Array::TablePresenter
+Hash.include CoreExtensions::Hash::TablePresenter
+
+
+read_yml = -> (key) do
+  YAML::load_file( File.expand_path('../../config.yml',__FILE__) )[key]
+end
+def list_types  db= Arcade::Api.databases.first 
+   list=  Arcade::Api.query(db){ "select from schema:types" }
+   puts "list: #{list}"
+   output = Terminal::Table.new do |t|
+     t.title = "database: #{db}"
+     t.headings =   ["Name" , "Parents", "Type", 'Properties','Unique', 'Automatic']
+     t.style = { :border => :markdown }
+     list.each do |row|
+       t.add_row [ row['name'],row['parent_types'],row['type'] ]
+       if  !row['indexes'].empty?
+         t.add_separator
+         row['indexes'].each do |i|
+           t.add_row [i['name'], i['typeName'], i['type'],i['properties'], i['unique'],i['automatic'] ]
+         end
+       end
+       if  !row['properties'].empty?
+         t.add_separator
+         row['properties'].each do |p|
+           t.add_row[p['name'],p['id'],p['type']]
+         end
+       end
+     end
+   end
+end
+
+
+
+
+
+include Arcade
+
+puts "-"*80
+puts "---   Namespace Arcade is included "
+puts ""
+puts " Available ArcadeDB-Statements"
+puts " ----------------------------"
+puts " Api.databases                   # returns an Array of known databases       "
+puts " Api.create_database <a string>  # returns true if succesfull   "
+puts " Api.drop_database   <a string>   "
+puts ""
+puts " Create and fetch documents and vertices"
+puts " ----------------------------"
+puts " Api.create_document <database>, <type>,    attribute: value   ,  ... "
+puts " Api.get_record <database>,  <rid>  #  returns a hash  "
+puts ""
+puts " submit queries"
+puts " ----------------------------"
+puts " Api.execute( <database> ) { <query> }  #submit query as block"
+puts " Api.query( <database> ) { <query> }    "
+puts ""
+puts "-"*80
+puts ""
+#C =  Arcade::Database.new
+#D = MiniSql::Connection.get( C.connection, {}  )
+#require 'pry'
+require 'irb'
+ARGV.clear
+IRB.start(__FILE__)
+#Pry.start(__FILE__)

data/bin/console

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+## loads the active-orient environment 
+## and starts an interactive shell
+##
+## Parameter:  
+##	       production (p)
+##	       development (d)  [default]
+##	       test (t)
+require 'bundler/setup'
+require 'terminal-table'
+require 'zeitwerk'
+require 'pastel'
+require 'arcade'
+require 'pry'
+#begin
+
+
+def browse  db: Arcade::Api.databases.first , extended: false
+
+  headings = -> do
+       ar= ["","Name" , "Parents", "Type","Properties", 'Unique', 'Automatic'] 
+       extended ?  ar : ar - ['Properties']
+  end
+  rows = ->(r) do
+         ar=["Type", r[:name],r[:parent_types],r[:type]," " ,  " "] 
+         !extended ? ar : ar + [""]
+  end
+  indizes = ->(i) do
+    if extended
+       ["Index",i[:name], "on #{i[:typeName]}", i[:type],i[:properties], i[:unique],i[:automatic] ]
+    else
+       ["Index",i[:name], "", i[:type], i[:unique],i[:automatic] ]
+    end
+  end
+
+   list=  Arcade::Api.query db, "select from schema:types" 
+   if list.is_a? Array
+     Terminal::Table.new do |t|
+       add_additional_separator =false 
+       t.title = "Database: #{db}"
+       t.headings =  headings.call
+#       t.style = { :border => :markdown }
+       t.style = { border: :unicode_thick_edge }
+       list.each.with_index do |row,j|
+         t.add_separator if (add_additional_separator || !row[:indexes].empty? || !row[:properties].empty?) && j >0
+         add_additional_separator =false 
+         t.add_row  rows[row]
+         if  !row[:indexes].empty?
+           add_additional_separator = true
+           row[:indexes].each do |i|
+             t.add_row indizes[i]
+           end
+         end
+         if  !row[:properties].empty?
+           add_additional_separator = true
+           row[:properties].each do |p|
+             ar= ["Property",p[:name],"",p[:type]," "," "] 
+             t.add_row !extended ? ar : ar + [""]
+           end
+         end
+       end
+     end
+   else
+     list
+   end
+end
+
+
+
+
+
+
+include Arcade
+
+def help
+p =  Pastel.new
+c =  p.bright_white.bold.on_yellow.detach
+g =  p.green.on_black.detach
+  puts "-"*80
+  puts " Namespace is: Arcade ! "
+  puts ""
+  puts c[" Essential ArcadeDB-Statements                                                  "]
+  puts " ----------------------------"
+  puts g[" Api.databases "]+"                  # returns an Array of known databases "
+  puts g[" Api.create_database <a string> "] + " # returns true if successfull   "
+  puts g[" Api.drop_database   <a string> "]
+  puts ""
+  puts " Create and fetch documents and vertices"
+  puts " ----------------------------"
+  puts g[" Api.create_document <database>, <type>,    attribute: value   ,  ... "]
+  puts g[" Api.get_record <database>,  <rid>  "] +"#  returns a hash  "
+  puts ""
+  puts " submit queries"
+  puts " ----------------------------"
+  puts g[" Api.execute( <database> ) { <query> } "]+" #submit query as block"
+  puts g[" Api.query <database> , <query>  "]
+  puts ""
+  puts " -----------------------------"
+  puts " Display the database-structure"
+  puts g[" puts browse db: \"name\", extended: \"false|true\" "]+ "browses the first database found, "
+  puts   "                                                      if called without parameters"
+  puts " Display this helpscreen:  "+ g["help"]
+  puts "-"*80
+  puts ""
+end
+
+help
+e=  ARGV.empty? ? :development :  ARGV.last.downcase.to_sym
+## load test model files
+#require "#{__dir__}/../spec/model_helper"
+
+loader =  Zeitwerk::Loader.new
+loader.push_dir ("#{__dir__}/../spec/model")
+loader.setup
+puts  "DB = Arcade::Database-instance"
+DB = Arcade::Init.connect e
+#require 'pry'
+require 'irb'
+ARGV.clear
+#begin
+#IRB.start(__FILE__)
+#rescue ArgumentError => e
+#  puts e
+##  retry
+#end
+Pry.start(__FILE__)

data/examples/books.rb

@@ -0,0 +1,139 @@
+=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 create a simple graph:
+
+Book --> HasContent --> KeyWord
+
+and to query it dynamically using Arcade::Query
+
+The model-files are located in `/spec/model/ex`
+
+There are 3 default search items provided. They are used if no parameter is given.
+However, any parameter given is transmitted as serach-criteria, ie.
+  ruby books.rb Juli August
+defines two search criteria.
+
+=end
+require 'bundler/setup'
+require 'yaml'
+require 'zeitwerk'
+require 'arcade'
+
+include Arcade
+## require modelfiles
+loader =  Zeitwerk::Loader.new
+loader.push_dir ("#{__dir__}/../spec/model")
+loader.setup
+
+   # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
+	 #################  read samples  ##############
+	 def read_samples
+		 print "\n === READ SAMPLES === \n"
+		 ## Lambda fill databasea
+		 # Anaylse a sentence
+		 # Split into words and upsert them to Word-Class.
+		 # The Block is only performed, if a new Word is inserted. 
+		 fill_database = ->(sentence, this_book ) do
+
+			 sentence.split(' ').map do | word |
+				 this_book.assign  vertex: Ex::Keyword.create( item: word ), via: Ex::HasContent if Ex::Keyword.where( item: word ).empty?
+			 end
+
+		 end
+		 ## Lambda 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 heute mit. Bei Werten im positiven Bereich signalisiert das Barometer ein Wachstum Ökonomen hatten eigentlich mit einem Anstieg auf 5,0 Punkte gerechnet'
+		 this_book =  Ex::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 =  Ex::Book.create title: 'second'
+		 fill_database[ words2, this_book ]
+		 puts "#{Ex::Keyword.count} keywords inserted into Database"
+	 end
+
+   # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
+	 #################  display books ##############
+	 def display_books_with *desired_words
+		 ## Each serach criteria becomes a subquery
+		 ## This is integrated into the main_query using 'let'.
+		 ## Subquery:  let ${a-y} = select expand(in('has_content')) from keyword where item = {search_word}
+		 ## combine with intercect: $z =  Intercect( $a ... $y )
+		 ##  Main Query is just
+		 ##  select expand( $z )  followed by all let-statements and finalized by "intercect"
+		 #
+
+		  # lambda to create subqueries
+      word_query = -> (arg) do
+				 q= Ex::Keyword.query  where: arg
+         q.nodes :in, via: Ex::HasContent
+			end
+
+      main_query =  Arcade::Query.new
+
+			## We just create "select expand($z)"
+      ## without 'expand' the result is "$z" -> "in(ex_has_content)"-> [ book-record ]
+      ## with 'expand'  its                     "in(ex_has_content)"-> [ book-record ]
+			main_query.expand( '$z' )
+
+
+      print("\n === display_books_with » #{ desired_words.join "," } « === \n")
+
+      intersects = Array.new
+      ## Now, add subqueries to the main-query
+      desired_words.each_with_index do | word, i |
+        symbol = ( i+97 ).chr   #  convert 1 -> 'a', 2 -> 'b' ...
+        main_query.let   symbol =>  word_query[ item: word  ]
+        intersects << "$#{symbol}"
+      end
+      ## Finally add the intersects statement
+      ## Use UnionAll for an superposition  of  positive seraches
+      ## Use Intercept for a positive search only if all parameters apply to one book.
+      #
+      main_query.let   "$z = unionall(#{intersects.join(', ')}) "
+      #main_query.let   "$z = Intersect(#{intersects.join(', ')}) "
+      puts "generated Query:"
+      puts main_query.to_s
+      puts "\n\n\n"
+      result = main_query.query.select_result
+      puts '-' * 23
+      print "found books: "
+      puts result.map( &:title ).uniq.join("; ")
+      if result.empty?
+        puts " -- None -- "
+        puts " try » ruby books.rb Japan Flaute «  for a positive search in one of the two sentences"
+      else
+        puts '-_' * 23
+        puts "that's it folks"
+      end
+   end
+
+ if $0 == __FILE__
+
+	 search_items =  ARGV.empty? ? ['China', 'aus', 'Flaute'] : ARGV
+
+       ## clear test database
+       databases =  Arcade::Api.databases
+       if  databases.include?(Arcade::Config.database[:test])
+         Arcade::Api.drop_database Arcade::Config.database[:test]
+       end
+       Arcade::Api.create_database Arcade::Config.database[:test]
+
+       Arcade::Init.connect 'test'
+
+       print "\n === REBUILD  finished=== \n"
+	## check wether the database tables exist. Then delete Database-Class and preallocated ruby-Object
+       print " creating Book and  Keyword as Vertex; HasContent as Edge \n"
+       Ex::Book.create_type
+       Ex::Keyword.create_type
+       Ex::HasContent.create_type
+       print "\n === PROPERTY === \n"
+
+       read_samples
+       display_books_with *search_items
+
+ end

data/examples/relation_1__1.rb

@@ -0,0 +1,149 @@
+##
+## This example realises an unidirectional Graph using
+## a document database primitve and a self referencing 1:1 relation.
+#
+## Modelfiles are located in spec/model.
+## The exampmle runs in the test environment.
+##
+require 'bundler/setup'
+require 'zeitwerk'       
+require 'arcade'
+
+include Arcade                  # Arcade Namespace is optional
+## require modelfiles
+loader =  Zeitwerk::Loader.new
+loader.push_dir ("#{__dir__}/../spec/model")
+loader.setup
+
+## clear test database
+
+databases =  Api.databases
+if  databases.include?(Config.database[:test])
+  Api.drop_database Config.database[:test]
+end
+Api.create_database Config.database[:test]
+
+## Universal Database handle
+DB = Init.connect 'test'
+
+## ------------------------------------------------------ End Setup ------------------------------------- ##
+##
+## We are realising  a self referencing  relation
+##  name -->   child
+#
+#  database schema
+#  CREATE DOCUMENT TYPE ex_names
+#  CREATE PROPERTY ex_names.child LINK
+#  CREATE PROPERTY ex_names.name STRING
+#  CREATE INDEX `Example[names]` ON ex_names ( name ) UNIQUE
+
+
+# Namespace for Data-Objects is `Ex`
+Ex::Names.create_type                                 # initialize the database
+                                                      # spec/models/ex/names.rb
+                                                      # Put some names into the database
+puts "-------------------- insert data ---------------------------------"
+table = %w( Guthorn Fulkerson Sniezek Tomasulo Portwine Keala Revelli Jacks Gorby Alcaoa ).map do | name |
+  Ex::Names.insert name: name, age: rand(99)
+end
+                                                      # Connect randomly
+children = (0..6).map{ | i | table[-i].rid    }
+table.each{| n | n.update  child:  table[ rand(10)].rid }
+
+puts "-------------------- raw data ---------------------------------"
+puts Ex::Names.all autoload: false                    # display links as rid (do not load the document)
+
+puts "--------------- Parent and Children ---------------------------"
+
+## Create a Query-Object and execute it  via `query`
+children_query  = Ex::Names.query projection:  ['name', 'child.name']
+puts children_query.query
+
+puts "--------------- unidirectional relation -----------------------"
+
+## Use the `Model.all` approach instead
+puts Ex::Names.all projection: ['name as parent',
+                                'age as parent_age',
+                                'child.age',
+                                'child.child.age as second_generation_age'],
+                   order: 'parent_age'
+
+
+puts "-----------------  query relation - teenager -------------------"
+
+teenager_query  = Ex::Names.query projection:  ['name as parent',
+                                                'child:{name, age} as teenager'],
+                                  where: 'child.age between 10 and 25'
+
+puts teenager_query.query
+
+__END__
+
+Expected result
+
+24.04.(11:12:58) INFO->Q: create document type ex_names
+24.04.(11:12:58) INFO->Q: CREATE PROPERTY ex_names.child LINK
+24.04.(11:12:58) INFO->Q: CREATE PROPERTY ex_names.name STRING
+24.04.(11:12:58) INFO->Q: CREATE INDEX `Example[names]` ON ex_names ( name ) UNIQUE
+-------------------- insert data ---------------------------------
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Guthorn","age":81}
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Fulkerson","age":16}
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Sniezek","age":50}
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Tomasulo","age":20}
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Portwine","age":7}
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Keala","age":57}
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Revelli","age":31}
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Jacks","age":23}
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Gorby","age":83}
+24.04.(11:12:58) INFO->Q: INSERT INTO ex_names CONTENT {"name":"Alcaoa","age":58}
+24.04.(11:12:58) INFO->Q: update #1:0 set child = '#2:1' return after $current
+24.04.(11:12:58) INFO->Q: update #2:0 set child = '#3:0' return after $current
+24.04.(11:12:58) INFO->Q: update #3:0 set child = '#1:0' return after $current
+24.04.(11:12:58) INFO->Q: update #4:0 set child = '#1:1' return after $current
+24.04.(11:12:58) INFO->Q: update #5:0 set child = '#2:1' return after $current
+24.04.(11:12:58) INFO->Q: update #6:0 set child = '#2:1' return after $current
+24.04.(11:12:58) INFO->Q: update #7:0 set child = '#8:0' return after $current
+24.04.(11:12:58) INFO->Q: update #8:0 set child = '#6:0' return after $current
+24.04.(11:12:58) INFO->Q: update #1:1 set child = '#4:0' return after $current
+24.04.(11:12:58) INFO->Q: update #2:1 set child = '#1:1' return after $current
+-------------------- raw data ---------------------------------
+24.04.(11:12:58) INFO->Q: select from ex_names
+<ex_names[#1:0]: age : 81, child : <ex_names[#2:1]: age : 58, child : < ex_names: #1:1 >, name : Alcaoa>, name : Guthorn>
+<ex_names[#1:1]: age : 83, child : <ex_names[#4:0]: age : 20, child : < ex_names: #1:1 >, name : Tomasulo>, name : Gorby>
+<ex_names[#2:0]: age : 16, child : <ex_names[#3:0]: age : 50, child : < ex_names: #1:0 >, name : Sniezek>, name : Fulkerson>
+<ex_names[#2:1]: age : 58, child : <ex_names[#1:1]: age : 83, child : < ex_names: #4:0 >, name : Gorby>, name : Alcaoa>
+<ex_names[#3:0]: age : 50, child : <ex_names[#1:0]: age : 81, child : < ex_names: #2:1 >, name : Guthorn>, name : Sniezek>
+<ex_names[#4:0]: age : 20, child : <ex_names[#1:1]: age : 83, child : < ex_names: #4:0 >, name : Gorby>, name : Tomasulo>
+<ex_names[#5:0]: age : 7, child : <ex_names[#2:1]: age : 58, child : < ex_names: #1:1 >, name : Alcaoa>, name : Portwine>
+<ex_names[#6:0]: age : 57, child : <ex_names[#2:1]: age : 58, child : < ex_names: #1:1 >, name : Alcaoa>, name : Keala>
+<ex_names[#7:0]: age : 31, child : <ex_names[#8:0]: age : 23, child : < ex_names: #6:0 >, name : Jacks>, name : Revelli>
+<ex_names[#8:0]: age : 23, child : <ex_names[#6:0]: age : 57, child : < ex_names: #2:1 >, name : Keala>, name : Jacks>
+--------------- Parent and Children ---------------------------
+24.04.(11:12:58) INFO->Q: select name, child.name from ex_names
+{:name=>"Guthorn", :"child.name"=>"Alcaoa"}
+{:name=>"Gorby", :"child.name"=>"Tomasulo"}
+{:name=>"Fulkerson", :"child.name"=>"Sniezek"}
+{:name=>"Alcaoa", :"child.name"=>"Gorby"}
+{:name=>"Sniezek", :"child.name"=>"Guthorn"}
+{:name=>"Tomasulo", :"child.name"=>"Gorby"}
+{:name=>"Portwine", :"child.name"=>"Alcaoa"}
+{:name=>"Keala", :"child.name"=>"Alcaoa"}
+{:name=>"Revelli", :"child.name"=>"Jacks"}
+{:name=>"Jacks", :"child.name"=>"Keala"}
+--------------- unidirectional relation -----------------------
+24.04.(11:12:58) INFO->Q: select name as parent, age as parent_age, child.age, child.child.age as second_generation_age from ex_names order by parent_age
+{:parent=>"Portwine", :parent_age=>7, :second_generation_age=>83, :"child.age"=>58}
+{:parent=>"Fulkerson", :parent_age=>16, :second_generation_age=>81, :"child.age"=>50}
+{:parent=>"Tomasulo", :parent_age=>20, :second_generation_age=>20, :"child.age"=>83}
+{:parent=>"Jacks", :parent_age=>23, :second_generation_age=>58, :"child.age"=>57}
+{:parent=>"Revelli", :parent_age=>31, :second_generation_age=>57, :"child.age"=>23}
+{:parent=>"Sniezek", :parent_age=>50, :second_generation_age=>58, :"child.age"=>81}
+{:parent=>"Keala", :parent_age=>57, :second_generation_age=>83, :"child.age"=>58}
+{:parent=>"Alcaoa", :parent_age=>58, :second_generation_age=>20, :"child.age"=>83}
+{:parent=>"Guthorn", :parent_age=>81, :second_generation_age=>83, :"child.age"=>58}
+{:parent=>"Gorby", :parent_age=>83, :second_generation_age=>83, :"child.age"=>20}
+-----------------  query relation - teenager -------------------
+24.04.(11:12:58) INFO->Q: select name as parent, child:{name, age} as teenager from ex_names where child.age between 10 and 25
+{:parent=>"Gorby", :teenager=>{:name=>"Tomasulo", :age=>20}}
+{:parent=>"Revelli", :teenager=>{:name=>"Jacks", :age=>23}}
+

data/examples/relation_1__n.rb

@@ -0,0 +1,56 @@
+##
+## This example realises a 1:n relation  using  a `embedded`property
+#
+## Its implemented in modelfiles located in spec/model
+#  and runs in the test environment.
+##
+require 'bundler/setup'
+require 'zeitwerk'
+require 'arcade'
+
+include Arcade
+## require modelfiles
+loader =  Zeitwerk::Loader.new
+loader.push_dir ("#{__dir__}/../spec/model")
+loader.setup
+
+## clear test database
+
+databases =  Arcade::Api.databases
+if  databases.include?(Arcade::Config.database[:test])
+  Arcade::Api.drop_database Arcade::Config.database[:test]
+end
+Arcade::Api.create_database Arcade::Config.database[:test]
+
+## Universal Database handle
+DB = Arcade::Init.connect 'test'
+
+## ------------------------------------------------------ End Setup ------------------------------------- ##
+##
+## We are realising  a self referencing  relation
+##  name -->   children
+#
+
+
+Ex::NewNames.create_type                              # initialize the database
+                                                      # spec/models/ex/new_names.rb
+                                                      # Put same names into the database
+table = %w( Guthorn Fulkerson Sniezek Tomasulo Portwine Keala Revelli Jacks Gorby Alcaoa ).map do | name |
+  Ex::NewNames.insert name: name, age: rand(99)
+end
+                                                      # Connect randomly
+children = (0..6).map{ | i | table[-i].rid    }
+puts children
+i = 0
+table.each.with_index do  | n, i |
+   n.update  children: [ children[i] &.rid, table[ rand(10)+5] &.rid].compact
+end
+
+puts "-------------------- raw data ---------------------------"
+puts Ex::NewNames.all false
+
+puts "--------------- Parent and Children ---------------------"
+
+children_query  = Ex::NewNames.query projection:  ['name as parent', 'children[age]']
+puts children_query.query
+