| 1 |
module Groonga |
| 2 |
class Table |
| 3 |
include Enumerable |
| 4 |
include Indexable |
| 5 |
|
| 6 |
def columns |
| 7 |
context = Context.instance |
| 8 |
column_ids.collect do |id| |
| 9 |
context[id] |
| 10 |
end |
| 11 |
end |
| 12 |
|
| 13 |
def each |
| 14 |
flags = |
| 15 |
TableCursorFlags::ASCENDING | |
| 16 |
TableCursorFlags::BY_ID |
| 17 |
TableCursor.open(self, :flags => flags) do |cursor| |
| 18 |
cursor.each do |id| |
| 19 |
yield(id) |
| 20 |
end |
| 21 |
end |
| 22 |
end |
| 23 |
|
| 24 |
def sort(keys, options={}) |
| 25 |
offset = options[:offset] || 0 |
| 26 |
limit = options[:limit] || -1 |
| 27 |
ensure_sort_keys(keys) do |sort_keys| |
| 28 |
sorted = Array.create("", self) |
| 29 |
begin |
| 30 |
sort_raw(sort_keys, offset, limit, sorted) |
| 31 |
rescue Exception |
| 32 |
sorted.close |
| 33 |
raise |
| 34 |
end |
| 35 |
sorted |
| 36 |
end |
| 37 |
end |
| 38 |
|
| 39 |
def group(keys, result) |
| 40 |
ensure_sort_keys(keys) do |sort_keys| |
| 41 |
group_raw(sort_keys, result) |
| 42 |
end |
| 43 |
end |
| 44 |
|
| 45 |
def apply_window_function(output_column, |
| 46 |
window_function_call, |
| 47 |
options={}) |
| 48 |
ensure_sort_keys_accept_nil(options[:sort_keys]) do |sort_keys| |
| 49 |
ensure_sort_keys_accept_nil(options[:group_keys]) do |group_keys| |
| 50 |
window_definition = WindowDefinition.new |
| 51 |
begin |
| 52 |
window_definition.sort_keys = sort_keys |
| 53 |
window_definition.group_keys = group_keys |
| 54 |
apply_window_function_raw(output_column, |
| 55 |
window_definition, |
| 56 |
window_function_call) |
| 57 |
ensure |
| 58 |
window_definition.close |
| 59 |
end |
| 60 |
end |
| 61 |
end |
| 62 |
end |
| 63 |
|
| 64 |
private |
| 65 |
def ensure_sort_keys_accept_nil(keys, &block) |
| 66 |
return yield(nil) if keys.nil? |
| 67 |
|
| 68 |
ensure_sort_keys(keys, &block) |
| 69 |
end |
| 70 |
|
| 71 |
def ensure_sort_keys(keys) |
| 72 |
if keys.is_a?(::Array) and keys.all? {|key| key.is_a?(TableSortKey)} |
| 73 |
return yield(keys) |
| 74 |
end |
| 75 |
|
| 76 |
converted_keys = [] |
| 77 |
|
| 78 |
begin |
| 79 |
keys = [keys] unless keys.is_a?(::Array) |
| 80 |
sort_keys = keys.collect do |key| |
| 81 |
ensure_sort_key(key, converted_keys) |
| 82 |
end |
| 83 |
yield(sort_keys) |
| 84 |
ensure |
| 85 |
converted_keys.each do |converted_key| |
| 86 |
converted_key.close |
| 87 |
end |
| 88 |
end |
| 89 |
end |
| 90 |
|
| 91 |
def ensure_sort_key(key, converted_keys) |
| 92 |
return key if key.is_a?(TableSortKey) |
| 93 |
|
| 94 |
sort_key = TableSortKey.new |
| 95 |
converted_keys << sort_key |
| 96 |
|
| 97 |
key_name = nil |
| 98 |
order = :ascending |
| 99 |
offset = 0 |
| 100 |
if key.is_a?(::Hash) |
| 101 |
key_name = key[:key] |
| 102 |
order = key[:order] || order |
| 103 |
offset = key[:offset] || offset |
| 104 |
else |
| 105 |
key_name = key |
| 106 |
end |
| 107 |
|
| 108 |
case key_name |
| 109 |
when String |
| 110 |
# Do nothing |
| 111 |
when Symbol |
| 112 |
key_name = key_name.to_s |
| 113 |
else |
| 114 |
message = "sort key name must be String or Symbol: " + |
| 115 |
"#{key_name.inspect}: #{key.inspect}" |
| 116 |
raise ArgumentError, message |
| 117 |
end |
| 118 |
|
| 119 |
if key_name.start_with?("-") |
| 120 |
key_name[0] = "" |
| 121 |
order = :descending |
| 122 |
elsif key_name.start_with?("+") |
| 123 |
key_name[0] = "" |
| 124 |
end |
| 125 |
|
| 126 |
key = find_column(key_name) |
| 127 |
if key.nil? |
| 128 |
table_name = name || "(temporary)" |
| 129 |
message = "unknown key: #{key_name.inspect}: " |
| 130 |
message << "#{table_name}(#{size})" |
| 131 |
raise ArgumentError, message |
| 132 |
end |
| 133 |
|
| 134 |
sort_key.key = key |
| 135 |
if order == :ascending |
| 136 |
sort_key.flags = Groonga::TableSortFlags::ASCENDING |
| 137 |
else |
| 138 |
sort_key.flags = Groonga::TableSortFlags::DESCENDING |
| 139 |
end |
| 140 |
sort_key.offset = offset |
| 141 |
sort_key |
| 142 |
end |
| 143 |
end |
| 144 |
end |