Class: Neo4j::Session

Inherits:
Object
  • Object
show all
Defined in:
lib/neo4j/session.rb

Defined Under Namespace

Classes: CypherError

Constant Summary collapse

@@current_session = 
nil
@@all_sessions = 
{}
@@factories = 
{}

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

._listeners ⇒ Object 



170
171
172
173
 
# File 'lib/neo4j/session.rb', line 170

def _listeners
  @@listeners ||= []
  @@listeners
end

._notify_listeners(event, data) ⇒ Object 



176
177
178
 
# File 'lib/neo4j/session.rb', line 176

def _notify_listeners(event, data)
  _listeners.each {|li| li.call(event, data)}
end

.add_listener(&listener) ⇒ Object 



165
166
167
 
# File 'lib/neo4j/session.rb', line 165

def add_listener(&listener)
  self._listeners << listener
end

.create_session(db_type, params = {}) ⇒ Object 



108
109
110
111
112
113
 
# File 'lib/neo4j/session.rb', line 108

def create_session(db_type, params = {})
  unless (@@factories[db_type])
    raise "Can't connect to database '#{db_type}', available #{@@factories.keys.join(',')}"
  end
  @@factories[db_type].call(*params)
end

.current ⇒ Neo4j::Session

Returns the current session.

Returns:



116
117
118
 
# File 'lib/neo4j/session.rb', line 116

def current
  @@current_session
end

.current! ⇒ Object

Returns the current session or raise an exception if no session is available



121
122
123
124
 
# File 'lib/neo4j/session.rb', line 121

def current!
  raise "No session, please create a session first with Neo4j::Session.open(:server_db) or :embedded_db" unless current
  current
end

.inspect ⇒ Object 



196
197
198
 
# File 'lib/neo4j/session.rb', line 196

def inspect
   "Neo4j::Session available: #{@@factories && @@factories.keys}"
end

.named(name) ⇒ Object

Returns a session with given name or else raise an exception



132
133
134
 
# File 'lib/neo4j/session.rb', line 132

def named(name)
  @@all_sessions[name] || raise("No session named #{name}.")
end

.on_session_available(&callback) ⇒ Object

Registers a callback which will be called immediately if session is already available, or called when it later becomes available.



144
145
146
147
148
149
150
151
 
# File 'lib/neo4j/session.rb', line 144

def on_session_available(&callback)
  if (Neo4j::Session.current)
    callback.call(Neo4j::Session.current)
  end
  add_listener do |event, data|
    callback.call(data) if event == :session_available
  end
end

.open(db_type = :server_db, *params) ⇒ Object

Creates a new session to Neo4j. This will be the default session to be used unless there is already a session created (see #current and #set_current)

Examples:

A Neo4j Server session

Neo4j::Session.open(:server_db, 'http://localhost:7474', {basic_auth: {username: 'foo', password: 'bar'}})

Using a user defined Faraday HTTP connection

connection = Faraday.new do |b|
  # faraday config
end
Neo4j::Session.open(:server_db, 'http://localhost:7474', connection: connection)

A embedded Neo4j session

Neo4j::Session.open(:embedded_db, 'path/to/db')

Parameters:

  • db_type (defaults to: :server_db) —

    the type of database, e.g. :embedded_db, or :server_db

See Also:

  • Neo4j::Server::CypherSession#open for :server_db params


98
99
100
 
# File 'lib/neo4j/session.rb', line 98

def open(db_type=:server_db, *params)
  register(create_session(db_type, params))
end

.open_named(db_type, name, default = nil, *params) ⇒ Object 



102
103
104
105
 
# File 'lib/neo4j/session.rb', line 102

def open_named(db_type, name, default = nil, *params)
  raise "Multiple sessions is currently only supported for Neo4j Server connections." unless db_type == :server_db
  register(create_session(db_type, params), name, default)
end

.query(*args) ⇒ Object

See Also:



127
128
129
 
# File 'lib/neo4j/session.rb', line 127

def query(*args)
  current!.query(*args)
end

.register(session, name = nil, default = nil) ⇒ Object 



181
182
183
184
185
186
187
188
189
 
# File 'lib/neo4j/session.rb', line 181

def register(session, name = nil, default = nil)
  if default == true
    set_current(session)
  elsif default.nil?
    set_current(session) unless @@current_session
  end
  @@all_sessions[name] = session if name
  session
end

.register_db(db, &session_factory) ⇒ Object 



201
202
203
204
 
# File 'lib/neo4j/session.rb', line 201

def register_db(db, &session_factory)
  puts "replace factory for #{db}" if @@factories[db]
  @@factories[db] = session_factory
end

.set_current(session) ⇒ Object

Sets the session to be used as default

Parameters:



138
139
140
 
# File 'lib/neo4j/session.rb', line 138

def set_current(session)
  @@current_session = session
end

.unregister(session) ⇒ Object 



192
193
194
 
# File 'lib/neo4j/session.rb', line 192

def unregister(session)
  @@current_session = nil if @@current_session == session
end

.user_agent_string ⇒ Object 



153
154
155
156
157
158
159
160
161
162
 
# File 'lib/neo4j/session.rb', line 153

def user_agent_string
  gem, version = if defined?(::Neo4j::ActiveNode)
                   ['neo4j', ::Neo4j::VERSION]
                 else
                   ['neo4j-core', ::Neo4j::Core::VERSION]
                 end


  "#{gem} gem/#{version} (https://github.com/neo4jrb/#{gem})"
end

Instance Method Details

#_query(*params) ⇒ Object

This method is abstract.

Same as #query but does not accept an DSL and returns the raw result from the database. Notice, it might return different values depending on which database is used, embedded or server.



76
77
78
 
# File 'lib/neo4j/session.rb', line 76

def _query(*params)
  raise 'not implemented'
end

#auto_commit? ⇒ Boolean

Returns:

  • (Boolean) 


36
37
38
 
# File 'lib/neo4j/session.rb', line 36

def auto_commit?
  true # TODO
end

#begin_tx ⇒ Object

This method is abstract. 


41
42
43
 
# File 'lib/neo4j/session.rb', line 41

def begin_tx
  raise "not impl."
end

#close ⇒ Object

This method is abstract. 


9
10
11
 
# File 'lib/neo4j/session.rb', line 9

def close
  self.class.unregister(self)
end

#db_type ⇒ :embedded_db | :server_db

Returns:

  • (:embedded_db | :server_db) 


32
33
34
 
# File 'lib/neo4j/session.rb', line 32

def db_type
  raise "not impl."
end

#query(options = {}) ⇒ Neo4j::Core::Query, Enumerable

Performs a cypher query. See Core::Query for more details, but basic usage looks like:

Examples:

Using cypher DSL

Neo4j::Session.query.match("(c:person)-[:friends]->(p:person)").where(c: {name: 'andreas'}).pluck(:p).first[:name]

Show the generated Cypher

Neo4j::Session.query..match("(c:person)-[:friends]->(p:person)").where(c: {name: 'andreas'}).return(:p).to_cypher

Use Cypher string instead of the cypher DSL

Neo4j::Session.query("MATCH (c:person)-[:friends]->(p:person) WHERE c.name = \"andreas\" RETURN p").first[:p][:name]

Returns:

  • (Neo4j::Core::Query, Enumerable) —

    return a Query object for DSL or a Enumerable if using raw cypher strings

See Also:



69
70
71
 
# File 'lib/neo4j/session.rb', line 69

def query(options = {})
  raise 'not implemented, abstract'
end

#running ⇒ Object

This method is abstract.

Only for embedded database



27
28
29
 
# File 'lib/neo4j/session.rb', line 27

def running
  raise "not impl."
end

#shutdown ⇒ Object

This method is abstract.

Only for embedded database



21
22
23
 
# File 'lib/neo4j/session.rb', line 21

def shutdown
  raise "not impl."
end

#start ⇒ Object

This method is abstract.

Only for embedded database



15
16
17
 
# File 'lib/neo4j/session.rb', line 15

def start
  raise "not impl."
end