Class: FluentQuery::Connection

Inherits:
Object
  • Object
show all
Defined in:
lib/fluent-query/connection.rb

Overview

Represents query target connection.

Instance Method Summary collapse

Constructor Details

#initialize(driver_class, settings = nil, open = true) ⇒ Connection

Returns a new instance of Connection.



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/fluent-query/connection.rb', line 53

def initialize(driver_class, settings = nil, open = true)

    # Analyses

    driver = driver_class::new(self)

    if not driver.kind_of? FluentQuery::Driver
        raise FluentQuery::Exception::new("Driver must be subclass of the 'FluentQuery::Driver' class.")
    end

    # Assigns

    @_driver_class = driver_class
    @_settings = settings
    @_open = false
    @_debug = false

    # Opens if required

    if open
        @_driver = driver
        self.open!
    end
   
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(sym, *args, &block) ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/fluent-query/connection.rb', line 87

def method_missing(sym, *args, &block)
    
    # Checks if connection is in open state
    if not @_open
        raise FluentQuery::Exception::new("Connection is closed.")
    end

    ##
    
    driver = self.driver
    
    if driver.relevant_method? sym
        return __query_call(sym, *args, &block)
    else
        raise FluentQuery::Exception::new("Method '" << sym.to_s << "' isn't implemented by associated FluentQuery::Driver or FluentQuery::Connection object.")
    end
end

Instance Method Details

#close! ⇒ Object 



186
187
188
189
190
191
192
193
 
# File 'lib/fluent-query/connection.rb', line 186

def close!
    if @_driver
        self.driver.close_connection!
        @_driver = nil
    end
    
    @_open = false
end

#do(query) ⇒ Object 



230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
 
# File 'lib/fluent-query/connection.rb', line 230

def do(query)

    # Checks if connection is in open state
    if not @_open
        raise FluentQuery::Exception::new("Connection is closed.")
    end

    # If query is fluent query object, executes it
    if query.kind_of? FluentQuery::Query
        result = query.do!
    else
        if @_debug == :dump_all
            puts query
        end
            
        result = self.driver.do(query)
    end

    return result
    
end

#driver ⇒ Object 



144
145
146
147
148
149
150
151
152
 
# File 'lib/fluent-query/connection.rb', line 144

def driver

    # Checks if connection is in open state
    if @_driver.nil?
        @_driver = @_driver_class::new(self)
    end
    
    return @_driver
end

#execute(query) ⇒ Object 



200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/fluent-query/connection.rb', line 200

def execute(query)

    # Checks if connection is in open state
    if not @_open
        raise FluentQuery::Exception::new("Connection is closed.")
    end

    # If query is fluent query object, executes it
    if query.kind_of? FluentQuery::Query
        result = query.execute!
    else
        if @_debug == :dump_all
            puts query
        end
        
        result = self.driver.execute(query)
    end

    # Wraps driver result to result class
    result = FluentQuery::Result::new(result)

    return result
    
end

#open!(settings = nil) ⇒ Object 



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/fluent-query/connection.rb', line 159

def open!(settings = nil)

    if @_open
        raise FluentQuery::Exception::new("Connection is already open.")
    end

    ##

    if (settings == nil) and @_settings
        settings = @_settings
    elsif settings == nil
        raise FluentQuery::Exception::new("Connection settings hasn't been set or given to the #open method.")
    end
    
    self.driver.open_connection(settings)

    ##

    @_open = true
    
end

#query(*args, &block) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/fluent-query/connection.rb', line 126

def query(*args, &block)
    query = self._new_query_object
    
    # Calls given block in query context.
    if block
        result = query.instance_eval(&block)
    else
        result = query
    end
    
    return query
end

#set_debug(mode) ⇒ Object 



114
115
116
 
# File 'lib/fluent-query/connection.rb', line 114

def set_debug(mode)
    @_debug = mode
end

#transaction(&block) ⇒ Object 



257
258
259
260
261
262
263
264
265
266
 
# File 'lib/fluent-query/connection.rb', line 257

def transaction(&block)
    self.begin
    begin
        block.call
    rescue ::Exception => e
        self.rollback
        raise e
    end
    self.commit
end