May I ask some kind soul to criticize the following piece of code?
I don't have that much experience with Ruby yet, but I feel I could
do it simpler than that.
Problem: Fetch result of a query (it happens to be a SQL query to a
database, but the essential point here is that I need to generate
the resulting lines piecewise, each iteration returning the next
row as an array of values). The result should be returned as a
matrix (i.e. array of arrays). In practice, the number of rows returned
will be well below 1000, each row containing around 10 items.
Here is my code:
def fetch_result(querystring)
result=[]
qres = dbhandle.query(qstr)
while row = fetch_result.fetch_row # deliver next row
result.push row # add row to the result array - is this OK?
end
result # return result array
end
I suspect there might be an overhead in appending to an array
new rows piecewise as I'm doing it here. Is there a better way
to do it?
Ronald
···
--
Ronald Fischer <ronald.fischer@venyon.com>
Phone: +49-89-452133-162
Your sample seems to be missing something: Where does "fetch_result" come into existence? And why don't you use "qres"?
Attempting to answer your question, if you just append rows without modification you might as well do fetch_result.to_a.
Kind regards
robert
···
On 05.06.2007 16:12, Ronald Fischer wrote:
May I ask some kind soul to criticize the following piece of code?
I don't have that much experience with Ruby yet, but I feel I could
do it simpler than that.
Problem: Fetch result of a query (it happens to be a SQL query to a
database, but the essential point here is that I need to generate
the resulting lines piecewise, each iteration returning the next row as an array of values). The result should be returned as a matrix (i.e. array of arrays). In practice, the number of rows returned
will be well below 1000, each row containing around 10 items.
Here is my code:
def fetch_result(querystring)
result=
qres = dbhandle.query(qstr)
while row = fetch_result.fetch_row # deliver next row
result.push row # add row to the result array - is this OK?
end
result # return result array
end
I suspect there might be an overhead in appending to an array
new rows piecewise as I'm doing it here. Is there a better way
to do it?
Ronald
Problem: Fetch result of a query (it happens to be a SQL
query to a database, but the essential point here is that I
need to generate the resulting lines piecewise, each
iteration returning the next row as an array of values). The
result should be returned as a matrix (i.e. array of arrays).
In practice, the number of rows returned will be well below
1000, each row containing around 10 items.
Here is my code:
def fetch_result(querystring)
result=
qres = dbhandle.query(qstr)
while row = fetch_result.fetch_row # deliver next row
result.push row # add row to the result array - is this OK?
end
result # return result array
end
I suspect there might be an overhead in appending to an array
new rows piecewise as I'm doing it here. Is there a better
way to do it?
If the consumer of these data is just going to iterate over the
resulting array and do stuff with the rows, you might as well just yield
the results and cut out the middleman. It might look something like:
def each_result(query)
results = dbh.query(query)
while row = results.fetch_row
yield row
end
end
each_result {|row| puts row.inspect}
Of course, if you need an array for any reason, what you're doing
looking fine to me, although doing:
result << row
is more idiomatic ruby, I believe.
- donald
> def fetch_result(querystring)
> result=
> qres = dbhandle.query(qstr)
> while row = fetch_result.fetch_row # deliver next row
> result.push row # add row to the result array - is this OK?
> end
> result # return result array
> end
Your sample seems to be missing something: Where does "fetch_result"
come into existence? And why don't you use "qres"?
Sorry, my fault when condensing the original code to a form better
useful for discussing this issue (and during which I also renamed
variables to make understanding easier in this context). The
line should say:
while row = qres.fetch_row ....
Attempting to answer your question, if you just append rows without
modification you might as well do fetch_result.to_a.
Given my corrections, I guess you would propose
result = qres.to_a
Right? But this would give:
warning: default `to_a' will be obsolete
and not return the result. The reason is that qres is, in my case, the
result object for a MySql query, so I think to_a is not applicable here.
Ronald
···
--
Ronald Fischer <ronald.fischer@venyon.com>
Phone: +49-89-452133-162
Hm, it does not implement to_a properly? I guess then it does not extend Enumerable as well. You can do this:
qres.extend(Enumerable).to_a
Kind regards
robert
···
On 06.06.2007 09:44, Ronald Fischer wrote:
def fetch_result(querystring)
result=
qres = dbhandle.query(qstr)
while row = fetch_result.fetch_row # deliver next row
result.push row # add row to the result array - is this OK?
end
result # return result array
end
Your sample seems to be missing something: Where does "fetch_result" come into existence? And why don't you use "qres"?
Sorry, my fault when condensing the original code to a form better
useful for discussing this issue (and during which I also renamed
variables to make understanding easier in this context). The
line should say:
while row = qres.fetch_row ....
Attempting to answer your question, if you just append rows without modification you might as well do fetch_result.to_a.
Given my corrections, I guess you would propose
result = qres.to_a
Right? But this would give:
warning: default `to_a' will be obsolete
and not return the result. The reason is that qres is, in my case, the
result object for a MySql query, so I think to_a is not applicable here.