rails_age 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0856a8b6ebd00d824cb655f76712731b5f1034250520ddf90008099863ce70ff'
-  data.tar.gz: 38bfd628af67308dc59ec42eb3c7e89e6f2391c9bc4d84fd27fd24dfba89a4cd
+  metadata.gz: e75dd885fd2214ee3d6cbf5424406f26ba390a51a5bea08999998908e5bf24da
+  data.tar.gz: 9347d365deecd63c0ef5a48877c568db1e246d27d8cdfb031c693fc4c017ece2
 SHA512:
-  metadata.gz: c7f10fc55865bda5020d850470e103b1e8172e3b6fcf1be8a9fe7ecbac2b8617326cdbd3048bf241b5f5fe5a72a414d67f1f58bc2d6d06df4faa7d426ab49e86
-  data.tar.gz: ba30bcf0dabd7a66e68038d0314379663e1a6058f2b433947d961588cd593b3c318f3eec81ef7691d007029efbafa64d3cc2ba7fe8d92b56f9d51b31a7cf8d7b
+  metadata.gz: 70170301c78e81a6756f2f2d09d63c9cbf79d5c24dcbd44c732b732b667172dcc74402f038142d9ae14024c9c944ccab467988d37014ccd0ec6837b2b93a4844
+  data.tar.gz: 68bcd97903344fba28cfa378b0feb96663997056c01a467a0c53399e124affd37462a4e2f58a8aa2377047ef61e411ffaf0cb8f63e1da6bd720623db14de0ab9

data/CHANGELOG.md

@@ -1,44 +1,48 @@
 # Change Log
 
-## VERSION 0.9.1 - xxxx-xx-xx
+## VERSION 0.7.0 - 2025-06-01
 
-- **Edge Generator**
-  * add start-/end-nodes types to edge generator (would make scaffold easier), ie:
-    `rails generate apache_age:edge HasPet owner_role start_node:person end_node:pet`
-    with property and specified start-/end-nodes (person and pet nodes must have already been created)
+**Age Path** - nodes and edges combined
 
-- **Edge Scaffold** with node types?
-  * add `rails generate apache_age:edge_scaffold HasJob employee_role start_node:person end_node:company`
+- query paths (control path, length/depth and filtering using `match`)
+  - code: `Path.cypher(path_edge: HasChild, path_length: "1..5", path_properties: {guardian_role: 'father'}, start_node_filter: {first_name: 'Zeke'}, end_node_filter: {last_name: 'Flintstone'})`
+  - code.to_sql: `SELECT * FROM cypher('age_schema', $$ MATCH path = (start_node {first_name: 'Zeke'})-[HasChild*1..5 {guardian_role: 'father'}]->(end_node {last_name: 'Flintstone'}) RETURN path $$) AS (path agtype);`
 
-## VERSION 0.9.0 - 2024-xx-xx
-- **AGE visual paths graph**
-  * add `rails generate apache_age:visualize`
+**to_rich_h**
 
-## VERSION 0.8.0 - 2024-xx-xx
+- added to_rich_h method to nodes, edges and paths (displays additional context information for readability and represents data closer to the original age data)
 
-- **cypher queries** (like active record queries)
-  * schema override
-  * query support
-  * paths support
-  * select attributes support
+**Generic Queries**
 
-## VERSION 0.8.0 - 2024-xx-xx
+- ApacheAge::Node and ApacheAge::Edge can be used as the base for a query and return results instantiating the correct class (node, edge or path)
 
-breaking change?: namespaces (by default) will use their own schema? (add to database.yml & schema.rb ?)
+**Read Me** largely updated
 
-- **AGE Schema override**
+**Query Values**
 
-- **Multiple AGE Schema**
+- data casting within query code (so that matches are accurate)
+  * string
+  * integer
+  * decimal
+  * date
+  * datetime
+  * boolean
 
-## VERSION 0.7.0 - 2024-xx-xx
+Not implemented (on the rails side)
+  * array
+  * hash
+  * json
 
-- **Age Path** - nodes and edges combined
-  * add `rails generate apache_age:path_scaffold HasJob employee_role start_node:person end_node:company`
 
 ## VERSION 0.6.4 - 2024-10-30
 
 - **Query Sanitize**:
   * allow and sanitize query strings with multiple attributes, ie: `Person.where("find.first_name = ? AND find.last_name = ?", 'John', 'Doe')`
+  NOTE: for now the following keyords MuST be in caps!
+  ```
+  operators = ['=', '>', '<', '<>', '>=', '<=', '=~', 'ENDS WITH', 'CONTAINS', 'STARTS WITH', 'IN', 'IS NULL', 'IS NOT NULL']
+  separators = ["AND NOT", "OR NOT", "AND", "OR", "NOT"]
+  ```
 
 ## VERSION 0.6.3 - 2024-10-27
 

data/README.md

@@ -2,36 +2,387 @@
 
 Apache Age integration within a Rails application.
 
+Inspired by: https://github.com/apache/age/issues/370
+
 ## Quick Start - Essentials
 
-**NOTE:** you must be using Postgres as your database! Apache Age requires it.
+### Overview
+
+This Gem uses 3 Major Concepts:
+
+1. **Nodes** (Vertices) - usually nouns
+2. **Edges** (Relationships) - usually verbs (or relational adjectives)
+3. **Paths** (connections between nodes - heavy dependend on the `match` feature in cypher)
+
+In this mini example we have the Flintstone Family Tree.
+- Person (Node) - has attributes: first_name, last_name, gender
+- Pet (Node) - has attributes: name, gender, species
+- HasChild (Edge) - has attributes: guardian_role
+- HasSibling (Edge) - has attributes: relation
+- HasSpouse (Edge) - has attributes: spousal_role
+- HasJob (Edge) - has attributes: employee_role
+
+Paths are how you build the `network` of nodes and edges.
+
+
+### Generators - simplify usage and rails integration
+
+we have an installers and generators (we handle namespacing fully)
+
+RailsAge generators (and generally support standard Rails datatypes) - not all AGE datatypes are supported (yet)
+
+This includes:
+  * string
+  * integer
+  * decimal
+  * date
+  * datetime
+  * boolean
+
+AGE supports (but not RailsAge):
+  * array
+  * hash
+  * json
+
+**Installers**
 
 ```bash
-bundle add rails_age
-bundle install
-bin/rails apache_age:install
-# optional: prevents `bin/rails db:migrate` from modifying the schema file,
-# bin/rails apache_age:override_db_migrate
-git add .
-git commit -m "Add & configure Apache Age within Rails"
-```
+rails generate apache_age:install
 
-## Generators
+# optional, but handy, it prevents `bin/rails db:migrate` from breaking the schema file,
+rails generate apache_age:override_db_migrate
+```
 
 **NODES**
 
 ```bash
 rails generate apache_age:scaffold_node Company company_name
-
 rails generate apache_age:scaffold_node Person first_name last_name
 ```
 
 **EDGES**
 
 ```bash
+rails generate apache_age:scaffold_edge HasChild guardian_role
 rails generate apache_age:scaffold_edge HasJob employee_role start_date:date
+rails generate apache_age:scaffold_edge HasSibling start_relation
+rails generate apache_age:scaffold_edge HasSpouse spousal_role
+```
+
+
+### INSTALL APACHE AGE
+
+[Install Apache Age](https://age.apache.org/getstarted/quickstart)
+
+**Quick Docker Install**
+
+```bash
+# pull the docker image
+docker pull apache/age
+
+# Create AGE docker container
+docker run \
+  --name age  \
+  -p 5455:5432 \
+  -e POSTGRES_USER=postgresUser \
+  -e POSTGRES_PASSWORD=postgresPW \
+  -e POSTGRES_DB=postgresDB \
+  -d \
+  apache/age
+
+# enter the container and connect to the database (and test it)
+docker exec -it age psql -d postgresDB -U postgresUser
+
+# For every connection of AGE you start, you will need to load the AGE extension.
+CREATE EXTENSION age;
+LOAD 'age';
+SET search_path = ag_catalog, "$user", public;
+```
+
+
+### RAILS PROJECT (Flintstone Family)
+
+**NOTE:** you must be using Postgres as your database!
+
+Apache Age requires using Postgres (`-d postgresql`)!
+
+```bash
+# SETUP A RAILS PROJECT (Flintstone Family Tree)
+rails new stone_age -T -d postgresql
+cd stone_age
+git commit -m "initail commit"
+
+# if using the default dockerized AGE PostgreSQL server then add the following to your `config/database.yml`
+# BE SURE TO MATCH THE USERNAME AND PASSWORD TO WHAT YOU SET IN THE DOCKER RUN COMMAND!
+host: localhost
+port: 5455
+username: postgresUser
+password: postgresPW
+
+# create the database
+rails db:create
+
+# add the rails_age gem to your Gemfile
+bundle add rails_age
+
+# download the rails_age gem
+bundle install
+
+# configure the Apache AGE gem (ignore the OID warnings)
+bin/rails apache_age:install
+# if you get the error: `PG::FeatureNotSupported: ERROR:  extension "age" is not available`
+# then you have not installed the AGE code (in PostgreSQL) follow this instrcutions at:
+# https://github.com/apache/age?tab=readme-ov-file#installation
+
+# optional: prevents `bin/rails db:migrate` from modifying the schema file,
+bin/rails apache_age:override_db_migrate
+bin/rails db:migrate
+
+# create nodes
+bin/rails generate apache_age:scaffold_node Company company_name industry
+bin/rails generate apache_age:scaffold_node Person first_name last_name gender
+bin/rails generate apache_age:scaffold_node Pet name gender species
+# adjust the validations in the nodes files
+
+# create edges (relationships)
+bin/rails generate apache_age:scaffold_edge HasChild guardian_role:string
+bin/rails generate apache_age:scaffold_edge HasSibling relation:string
+bin/rails generate apache_age:scaffold_edge HasSpouse spousal_role:string
+bin/rails generate apache_age:scaffold_edge HasJob employee_role:string
+
+# adjust the edge validations and start_node and end_node types: ie: thefore
+# `HasChild` edge should add the model type following start_node and end_node
+# in this case: `:person`
+# app/edges/has_child.rb
+class HasChild
+  include ApacheAge::Entities::Edge
+
+  attribute :guardian_role, :string
+  attribute :start_node, :person
+  attribute :end_node, :person
+end
+
+# seed file uses `db/seed.rb` (seed provides NO pets)
+bin/rails db:seed
+
+# list noutes
+bin/rails routes
+
+# start server `bin/rails s`
+# or more likely when using JS:
+bin/start
+
+# visit the routes in your browser - you should have a basic but working AGE app - that can do both AGE (Graph) and normal Rails activities
 ```
 
+
+
+## Queries
+
+Mostly mimic **ActiveRecord** queries - if the class is an AGE based object (ie: a node or edge) then the queries are rewritten into AGE queries before being executed.  Age queries also automatically unwrap the results turning them into the appropriate Ruby class (node or edge).
+
+1. `.all`
+2. `.first`
+2. `.save`
+2. `.update`
+2. `.destroy`
+2. `.destroy_all` (not implemented)
+2. `.update_attributes`
+2. `.find(id)`
+2. `.exists?` (not implemented)
+3. `.find_by(first_name: 'Zeke', last_name: 'Flintstone')`
+3. `.where(first_name: 'Zeke', last_name: 'Flintstone')`
+4. `.order(last_name: :desc, first_name: :asc)`
+5. `.limit(3)` (returns the first 3 records)
+6. `.to_sql` (returns the SQL query)
+7. `.cypher` (primarily for path queries - _builds a specialized cypher query for efficetly doing path queries - building efficient `match` statements_)
+
+### Node Queries
+
+```ruby
+Dog.all
+Dog.where(name: 'Pema')
+
+Person.all
+Person.where(first_name: 'Zeke', last_name: 'Flintstone')
+
+ApacheAge::Node.all
+# untested applying a where on nodes of different types, but should work
+ApacheAge::Node.where(first_name: 'Zeke', last_name: 'Flintstone')
+```
+
+### Edge Queries
+
+```ruby
+HasChild.all
+HasChild.where(guardian_role: 'father')
+
+HasJob.all
+HasJob.where(employee_role: 'doctor')
+
+ApacheAge::Edge.all
+# untested applying a where on edges of different types, but should work
+ApacheAge::Edge.where(employee_role: 'doctor')
+```
+
+### Path Queries
+
+the connections between nodes and edges - this is important for advanced queries and relies heavily on the `match` feature in cypher (using match is faster for large datasets than using where to filter the data!)
+
+A Path Query must have the `cypher` method called on the `Path` class.  
+```ruby
+Path.cypher(path_edge: HasChild, path_length: "1..5", path_properties: {guardian_role: 'father'}, start_node_filter: {first_name: 'Zeke'}, end_node_filter: {last_name: 'Flintstone'})
+    .order(start_node: :last_name)
+    .limit(3)
+```
+**NOTE**: you can order on the start_node and end_node attributes, BUT NOT ON THE EDGE ATTRIBUTES (age limitation), even though you can filter on the edge attributes!
+
+A path query returns an array of paths (each path is an array of nodes and edges)
+```ruby
+[
+  [betty (node), bettys_son (edge), bamm_bamm (node)],
+  [betty (node), bettys_son (edge), bamm_bamm (node), bamm_bamms_son (edge), chip (node)]
+]
+```
+
+To make a path more readable for debugging you can use the `to_rich_h` method
+
+```ruby
+# hash metadata (rich hash) and is data is in properties (closer to the DB format)
+path_query.all.first.to_rich_h
+path_query.all.map(&:to_rich_h)
+# default to_h works on paths too with (flat data hash of record):
+path_query.all.first.map(&:to_h)
+path_query.all.map { |p| p.map(&:to_h) }
+```
+
+SQL Comparison with `match` and with `where` (in small datasets you won't see efficiency differences, but for large datasets `match` is much more efficient)
+```ruby
+# EFFICIENT - the data is filtered in one step during the data traversal
+Path.cypher(path_edge: HasChild, path_length: "1..5", path_properties: {guardian_role: 'father'}, start_node_filter: {first_name: 'Zeke'}, end_node_filter: {last_name: 'Flintstone'})
+    .order(start_node: {last_name: :asc}, length: :desc)
+    .limit(3).to_sql
+# SELECT *
+# FROM cypher('age_schema', $$
+#   MATCH path = (start_node {first_name: 'Zeke'})-[HasChild*1..5 {guardian_role: 'father'}]->(end_node {last_name: 'Flintstone'})
+#   RETURN path
+#   ORDER BY start_node.last_name ASC, length(path) DESC
+#   LIMIT 3
+# $$) AS (path agtype);
+
+
+# INEFFICIENT - because where is done after the match traversal (two steps through the data)
+Path.cypher(path_edge: HasChild, path_length: "1..5", path_properties: {guardian_role: 'father'})
+    .where(start_node: {first_name: 'Zeke'})
+    .where('end_node.last_name =~ ?', 'Flintstone')
+    .order(start_node: {last_name: :asc}, length: :desc)
+    .limit(3).to_sql
+# SELECT *
+# FROM cypher('age_schema', $$
+#   MATCH path = (start_node)-[HasChild*1..5 {guardian_role: 'father'}]->(end_node)
+#   WHERE start_node.first_name = 'Zeke' AND end_node.last_name =~ 'Flintstone'
+#   RETURN path
+#   ORDER BY start_node.last_name ASC, length(path) DESC
+#   LIMIT 3
+# $$) AS (path agtype);
+```
+
+## Console Usage
+
+**NOTE**
+using rails attributes complicates the default output of the model, thus it is strong recommended to use the `to_rich_h` method to display the results with meta_data so the class is known (or `to_h` - just the essential data).
+
+```ruby
+dino = Pet.create(name: 'Dino', gender: 'male', species: 'dinosaur')
+dino.to_rich_h
+
+# find a person
+fred = Person.find_by(first_name: 'Fred', last_name: 'Flintstone')
+fred.to_rich_h
+
+pebbles = Person.find_by(first_name: 'Pebbles')
+pebbles.to_rich_h
+
+# find an edge
+father_relationship = HasChild.find_by(start_node: fred, end_node: pebbles)
+father_relationship.to_h
+> {:id=>1407374883553310,
+ :end_id=>844424930131996,
+ :start_id=>844424930131986,
+ :role=>"father",
+ :end_node=>{:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"},
+ :start_node=>{:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"}}
+
+# where - find multiple nodes
+family = Person.where(last_name: 'Flintstone').order(:first_name).limit(4).all.puts family.map(&:to_h)
+
+family
+> [{:id=>844424930131974, :last_name=>"Flintstone", :first_name=>"Ed", :gender=>"male"},
+>  {:id=>844424930131976, :last_name=>"Flintstone", :first_name=>"Edna", :gender=>"female"},
+?  {:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"},
+>  {:id=>844424930131975, :last_name=>"Flintstone", :first_name=>"Giggles", :gender=>"male"}]
+
+# all - unsorted
+all_family = Person.where(last_name: 'Flintstone').all
+puts all_family.map(&:to_h)
+> {:id=>844424930131969, :last_name=>"Flintstone", :first_name=>"Zeke", :gender=>"female"}
+> {:id=>844424930131970, :last_name=>"Flintstone", :first_name=>"Jed", :gender=>"male"}
+> {:id=>844424930131971, :last_name=>"Flintstone", :first_name=>"Rockbottom", :gender=>"male"}
+> {:id=>844424930131974, :last_name=>"Flintstone", :first_name=>"Ed", :gender=>"male"}
+> {:id=>844424930131975, :last_name=>"Flintstone", :first_name=>"Giggles", :gender=>"male"}
+> {:id=>844424930131976, :last_name=>"Flintstone", :first_name=>"Edna", :gender=>"female"}
+> {:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"}
+> {:id=>844424930131987, :last_name=>"Flintstone", :first_name=>"Wilma", :gender=>"female"}
+> {:id=>844424930131995, :last_name=>"Flintstone", :first_name=>"Stoney", :gender=>"male"}
+> {:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"}
+
+# where - multiple edges (relations) - for now only edge attributes and start/end nodes can be queried
+parental_relations = HasChild.where(end_node: pebbles)
+puts parental_relations.map(&:to_h)
+> {:id=>1407374883553310, :end_id=>844424930131996, :start_id=>844424930131986, :role=>"father", :end_node=>{:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"}, :start_node=>{:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"}}
+> {:id=>1407374883553309, :end_id=>844424930131996, :start_id=>844424930131987, :role=>"mother", :end_node=>{:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"}, :start_node=>{:id=>844424930131987, :last_name=>"Flintstone", :first_name=>"Wilma", :gender=>"female"}}
+
+# Path Queries - returns all elements that match a given path to find specific sets of relationships
+path = Path.cypher(path_edge: HasChild, path_length: "1..5", path_properties: {guardian_role: 'father'}, start_node_filter: {first_name: 'Zeke'}, end_node_filter: {last_name: 'Flintstone'})
+    .order(start_node: {last_name: :asc}, length: :desc)
+    .limit(3)
+
+# should redo the example using: path.all.map(&:to_rich_h) to make more readable
+path.all.map { |p| p.map(&:to_h) }
+>[[{:id=>844424930131969, :first_name=>"Zeke", :last_name=>"Flintstone", :gender=>"female"},
+  {:id=>1407374883553281,
+   :end_id=>844424930131971,
+   :start_id=>844424930131969,
+   :guardian_role=>"mother",
+   :end_node=>{:id=>844424930131971, :first_name=>"Rockbottom", :last_name=>"Flintstone", :gender=>"male"},
+   :start_node=>{:id=>844424930131969, :first_name=>"Zeke", :last_name=>"Flintstone", :gender=>"female"}},
+  {:id=>844424930131971, :first_name=>"Rockbottom", :last_name=>"Flintstone", :gender=>"male"}],
+ [{:id=>844424930131969, :first_name=>"Zeke", :last_name=>"Flintstone", :gender=>"female"},
+  {:id=>1407374883553281,
+   :end_id=>844424930131971,
+   :start_id=>844424930131969,
+   :guardian_role=>"mother",
+   :end_node=>{:id=>844424930131971, :first_name=>"Rockbottom", :last_name=>"Flintstone", :gender=>"male"},
+   :start_node=>{:id=>844424930131969, :first_name=>"Zeke", :last_name=>"Flintstone", :gender=>"female"}},
+  {:id=>844424930131971, :first_name=>"Rockbottom", :last_name=>"Flintstone", :gender=>"male"},
+  {:id=>1407374883553284,
+   :end_id=>844424930131975,
+   :start_id=>844424930131971,
+   :guardian_role=>"father",
+   :end_node=>{:id=>844424930131975, :first_name=>"Giggles", :last_name=>"Flintstone", :gender=>"male"},
+   :start_node=>{:id=>844424930131971, :first_name=>"Rockbottom", :last_name=>"Flintstone", :gender=>"male"}},
+  {:id=>844424930131975, :first_name=>"Giggles", :last_name=>"Flintstone", :gender=>"male"}]]
+
+raw_pg_results = Person.where(last_name: 'Flintstone').order(:first_name).limit(4).execute
+=> #<PG::Result:0x000000012255f348 status=PGRES_TUPLES_OK ntuples=4 nfields=1 cmd_tuples=4>
+raw_pg_results.values
+> [["{\"id\": 844424930131974, \"label\": \"Person\", \"properties\": {\"gender\": \"male\", \"last_name\": \"Flintstone\", \"first_name\": \"Ed\"}}::vertex"],
+>  ["{\"id\": 844424930131976, \"label\": \"Person\", \"properties\": {\"gender\": \"female\", \"last_name\": \"Flintstone\", \"first_name\": \"Edna\"}}::vertex"],
+>  ["{\"id\": 844424930131986, \"label\": \"Person\", \"properties\": {\"gender\": \"male\", \"last_name\": \"Flintstone\", \"first_name\": \"Fred\"}}::vertex"],
+>  ["{\"id\": 844424930131975, \"label\": \"Person\", \"properties\": {\"gender\": \"male\", \"last_name\": \"Flintstone\", \"first_name\": \"Giggles\"}}::vertex"]]
+```
+
+
 Ideally, edit the HasJob class so that `start_node` would use a type `:person` and the `end_node` uses at type `:company` - this is not yet supported by the generator, but easy to do manually as shown below.  (The problem is that I havent been able to figure out how load all the rails types in the testing environment).
 
 ie:
@@ -78,6 +429,56 @@ $ psql -h localhost -p 5455 -U docker_username
 > \q
 ```
 
+### Experiment directly with AGE
+
+Play with AGE/cypher directly (if desired) - see: https://age.apache.org/getstarted/quickstart
+
+To create a graph, use the create_graph function located in the ag_catalog namespace.
+
+enter postgres via:
+- `psql -h localhost -p 5455 -U docker_username`
+or
+- `docker exec -it age psql -d postgresDB -U postgresUser`
+
+then in psql:
+```sql
+-- For every connection of AGE you start, you will need to load the AGE extension.
+CREATE EXTENSION age;
+LOAD 'age';
+SET search_path = ag_catalog, "$user", public;
+
+SELECT create_graph('graph_name');
+
+# To create a single vertex with label and properties, use the CREATE clause.
+SELECT *
+FROM cypher('graph_name', $$
+    CREATE (:label {property:"Node A"})
+$$) as (v agtype);
+
+# create a second vertex (node)
+SELECT *
+FROM cypher('graph_name', $$
+    CREATE (:label {property:"Node B"})
+$$) as (v agtype);
+
+# To create an edge between the nodes and set its properties:
+SELECT *
+FROM cypher('graph_name', $$
+    MATCH (a:label), (b:label)
+    WHERE a.property = 'Node A' AND b.property = 'Node B'
+    CREATE (a)-[e:RELTYPE {property:a.property + '<->' + b.property}]->(b)
+    RETURN e
+$$) as (e agtype);
+
+# Query the connected nodes:
+SELECT * from cypher('graph_name', $$
+        MATCH (V)-[R]-(V2)
+        RETURN V,R,V2
+$$) as (V agtype, R agtype, V2 agtype);
+
+\q
+```
+
 ### Install and Configure Rails (if not done already)
 
 AGE REQUIRES POSTGRESQL!
@@ -269,87 +670,6 @@ The generator will only allow `:node` (default type) since at the time of runnin
 `rails generate apache_age:node HasPet start_node:person end_node:pet caretaker_role`
 but that doesn't work yet!
 
-### AGE Rails Quick Example
-
-```bash
-rails new stone_age --database=postresql
-cd stone_age
-
-bundle add rails_age
-bundle install
-bin/rails apache_age:install
-bin/rails apache_age:override_db_migrate
-rails db:create
-rails db:migrate
-rails generate apache_age:scaffold_node Person first_name, last_name, gender
-rails generate apache_age:scaffold_node Pet name gender species
-rails generate apache_age:scaffold_edge HasChild role:string
-rails generate apache_age:scaffold_edge HasSibling role:string
-rails generate apache_age:scaffold_edge HasSpouse role:string
-
-# seed file: [db/seed.rb](SEED.md)
-rails db:seed
-
-# Console Usage (seed doesn't provide any pets)
-dino = Pet.create(name: 'Dino', gender: 'male', species: 'dinosaur')
-dino.to_h
-
-# find a person
-fred = Person.find_by(first_name: 'Fred', last_name: 'Flintstone')
-fred.to_h
-
-pebbles = Person.find_by(first_name: 'Pebbles')
-pebbles.to_h
-
-# find an edge
-father_relationship = HasChild.find_by(start_node: fred, end_node: pebbles)
-father_relationship.to_h
-> {:id=>1407374883553310,
- :end_id=>844424930131996,
- :start_id=>844424930131986,
- :role=>"father",
- :end_node=>{:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"},
- :start_node=>{:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"}}
-
-# where - find multiple nodes
-family = Person.where(last_name: 'Flintstone').order(:first_name).limit(4).all.puts family.map(&:to_h)
-
-family
-> [{:id=>844424930131974, :last_name=>"Flintstone", :first_name=>"Ed", :gender=>"male"},
->  {:id=>844424930131976, :last_name=>"Flintstone", :first_name=>"Edna", :gender=>"female"},
-?  {:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"},
->  {:id=>844424930131975, :last_name=>"Flintstone", :first_name=>"Giggles", :gender=>"male"}]
-
-# all - unsorted
-all_family = Person.where(last_name: 'Flintstone').all
-puts all_family.map(&:to_h)
-> {:id=>844424930131969, :last_name=>"Flintstone", :first_name=>"Zeke", :gender=>"female"}
-> {:id=>844424930131970, :last_name=>"Flintstone", :first_name=>"Jed", :gender=>"male"}
-> {:id=>844424930131971, :last_name=>"Flintstone", :first_name=>"Rockbottom", :gender=>"male"}
-> {:id=>844424930131974, :last_name=>"Flintstone", :first_name=>"Ed", :gender=>"male"}
-> {:id=>844424930131975, :last_name=>"Flintstone", :first_name=>"Giggles", :gender=>"male"}
-> {:id=>844424930131976, :last_name=>"Flintstone", :first_name=>"Edna", :gender=>"female"}
-> {:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"}
-> {:id=>844424930131987, :last_name=>"Flintstone", :first_name=>"Wilma", :gender=>"female"}
-> {:id=>844424930131995, :last_name=>"Flintstone", :first_name=>"Stoney", :gender=>"male"}
-> {:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"}
-
-# where - multiple edges (relations) - for now only edge attributes and start/end nodes can be queried
-parental_relations = HasChild.where(end_node: pebbles)
-puts parental_relations.map(&:to_h)
-> {:id=>1407374883553310, :end_id=>844424930131996, :start_id=>844424930131986, :role=>"father", :end_node=>{:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"}, :start_node=>{:id=>844424930131986, :last_name=>"Flintstone", :first_name=>"Fred", :gender=>"male"}}
-> {:id=>1407374883553309, :end_id=>844424930131996, :start_id=>844424930131987, :role=>"mother", :end_node=>{:id=>844424930131996, :last_name=>"Flintstone", :first_name=>"Pebbles", :gender=>"female"}, :start_node=>{:id=>844424930131987, :last_name=>"Flintstone", :first_name=>"Wilma", :gender=>"female"}}
-
-
-raw_pg_results = Person.where(last_name: 'Flintstone').order(:first_name).limit(4).execute
-=> #<PG::Result:0x000000012255f348 status=PGRES_TUPLES_OK ntuples=4 nfields=1 cmd_tuples=4>
-raw_pg_results.values
-> [["{\"id\": 844424930131974, \"label\": \"Person\", \"properties\": {\"gender\": \"male\", \"last_name\": \"Flintstone\", \"first_name\": \"Ed\"}}::vertex"],
->  ["{\"id\": 844424930131976, \"label\": \"Person\", \"properties\": {\"gender\": \"female\", \"last_name\": \"Flintstone\", \"first_name\": \"Edna\"}}::vertex"],
->  ["{\"id\": 844424930131986, \"label\": \"Person\", \"properties\": {\"gender\": \"male\", \"last_name\": \"Flintstone\", \"first_name\": \"Fred\"}}::vertex"],
->  ["{\"id\": 844424930131975, \"label\": \"Person\", \"properties\": {\"gender\": \"male\", \"last_name\": \"Flintstone\", \"first_name\": \"Giggles\"}}::vertex"]]
-```
-
 ### Age Cypher Queries
 
 ```ruby