sdbcli 1.3.6 → 1.4.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (9) hide show
  1. data/README +4 -0
  2. data/bin/sdbcli +5 -1
  3. data/lib/sdbcli/sdb-client.rb +1 -1
  4. data/lib/sdbcli/sdb-driver.rb +47 -1
  5. data/lib/sdbcli/sdb-parser.tab.rb +262 -231
  6. data/lib/sdbcli/sdb-parser.y +24 -11
  7. data/lib/sdbcli/sdb-runner.rb +4 -2
  8. data/lib/sdbcli/sdb-token-generator.rb +57 -0
  9. metadata +2 -1
data/README CHANGED
@@ -84,6 +84,10 @@ https://bitbucket.org/winebarrel/sdbcli
84
84
  displays a present result
85
85
  (CURRENT statement is published after SELECT statement)
86
86
 
87
+ PAGE number
88
+ displays a result of the specified page
89
+ (PAGE statement is published after SELECT statement)
90
+
87
91
  DESC domain_name
88
92
  displays information about the domain
89
93
 
data/bin/sdbcli CHANGED
@@ -1,7 +1,7 @@
1
1
  #!/usr/bin/env ruby
2
2
  $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
3
3
 
4
- Version = '1.3.6'
4
+ Version = '1.4.0'
5
5
  HISTORY_FILE = File.join((ENV['HOME'] || ENV['USERPROFILE'] || '.'), '.sdbcli_history')
6
6
  HISTSIZE = 500
7
7
  SELECT_LIMIT = 2500
@@ -398,6 +398,10 @@ CUR[RENT]
398
398
  displays a present result
399
399
  (CURRENT statement is published after SELECT statement)
400
400
 
401
+ PAGE number
402
+ displays a result of the specified page
403
+ (PAGE statement is published after SELECT statement)
404
+
401
405
  DESC domain_name
402
406
  displays information about the domain
403
407
 
data/lib/sdbcli/sdb-client.rb CHANGED
@@ -137,7 +137,7 @@ module SimpleDB
137
137
  if (error = doc.at_css('Errors Error'))
138
138
  code = error.at_css('Code').content
139
139
  message = error.at_css('Message').content
140
- raise Error, "#{code}: #{message}"
140
+ raise SimpleDB::Error, "#{code}: #{message}"
141
141
  end
142
142
  end
143
143
 
data/lib/sdbcli/sdb-driver.rb CHANGED
@@ -1,4 +1,6 @@
1
1
  require 'sdbcli/sdb-client'
2
+ require 'sdbcli/sdb-token-generator'
3
+ require 'strscan'
2
4
 
3
5
  module SimpleDB
4
6
  class Error < StandardError; end
@@ -164,6 +166,46 @@ module SimpleDB
164
166
  return items
165
167
  end
166
168
 
169
+ def page_to(page, consistent = false)
170
+ if page < 1
171
+ raise SimpleDB::Error, "Invalid page number: #{page}"
172
+ end
173
+
174
+ unless @select_expr
175
+ return []
176
+ end
177
+
178
+ ss = StringScanner.new(@select_expr.dup)
179
+ limit = 100
180
+
181
+ until ss.eos?
182
+ if ss.scan(/[^`'"L]+/i) #'
183
+ elsif ss.scan( /`(?:[^`]|``)*`/)
184
+ elsif ss.scan(/'(?:[^']|'')*'/) #'
185
+ elsif ss.scan(/"(?:[^"]|"")*"/) #"
186
+ elsif (tok = ss.scan /LIMIT\s+\d\b/i)
187
+ limit = tok.split(/\s+/).last.to_i
188
+ elsif ss.scan(/./)
189
+ end
190
+ end
191
+
192
+ params = {:SelectExpression => @select_expr, :ConsistentRead => consistent}
193
+ items = []
194
+
195
+ token = (page > 1) ? SimpleDB::TokenGenerator.next_token(limit, page) : :first
196
+
197
+ new_token = iterate(:select, params, token) do |doc|
198
+ doc.css('Item').map do |i|
199
+ items << [i.at_css('Name').content, attrs_to_hash(i)]
200
+ end
201
+ end
202
+
203
+ @current_token = token
204
+ @next_token = new_token
205
+
206
+ return items
207
+ end
208
+
167
209
  def delete(domain_name, items = {})
168
210
  until (chunk = items.slice!(0, MAX_NUMBER_SUBMITTED_ITEMS)).empty?
169
211
  params = {}
@@ -237,7 +279,11 @@ module SimpleDB
237
279
  token = nil
238
280
 
239
281
  while @token
240
- @params.update(:NextToken => @token.content) if @token != :first
282
+ if @token != :first
283
+ tok = @token.kind_of?(String) ? @token : @token.content
284
+ @params.update(:NextToken => tok)
285
+ end
286
+
241
287
  doc = @client.send(@method, @params)
242
288
  yield(doc)
243
289
  token = doc.at_css('NextToken')
data/lib/sdbcli/sdb-parser.tab.rb CHANGED
@@ -13,7 +13,7 @@ module SimpleDB
13
13
 
14
14
  class Parser < Racc::Parser
15
15
 
16
- module_eval(<<'...end sdb-parser.y/module_eval...', 'sdb-parser.y', 263)
16
+ module_eval(<<'...end sdb-parser.y/module_eval...', 'sdb-parser.y', 274)
17
17
 
18
18
  KEYWORDS = %w(
19
19
  ADD
@@ -92,16 +92,18 @@ def scan
92
92
  yield [:NEXT, @ss.scan(/\s*\|\s*.*/)]
93
93
  elsif (tok = @ss.scan /CUR(RENT)?\b/i)
94
94
  yield [:CURRENT, @ss.scan(/\s*\|\s*.*/)]
95
+ elsif (tok = @ss.scan /PAGE\s+\d+/i)
96
+ yield [:PAGE, tok + @ss.scan(/(\s*\|\s*.*)?/)]
95
97
  elsif (tok = @ss.scan /NULL\b/i)
96
98
  yield [:NULL, nil]
97
99
  elsif (tok = @ss.scan /`([^`]|``)*`/)
98
100
  yield [:IDENTIFIER, tok.slice(1...-1).gsub(/``/, '`')]
99
101
  elsif (tok = @ss.scan /'([^']|'')*'/) #'
100
- yield [:VALUE, tok.slice(1...-1).gsub(/''/, "'")]
102
+ yield [:STRING, tok.slice(1...-1).gsub(/''/, "'")]
101
103
  elsif (tok = @ss.scan /"([^"]|"")*"/) #"
102
- yield [:VALUE, tok.slice(1...-1).gsub(/""/, '"')]
104
+ yield [:STRING, tok.slice(1...-1).gsub(/""/, '"')]
103
105
  elsif (tok = @ss.scan /\d+(\.\d+)?/)
104
- yield [:VALUE, tok]
106
+ yield [:NUMBER, tok]
105
107
  elsif (tok = @ss.scan /[,\(\)\*]/)
106
108
  yield [tok, tok]
107
109
  elsif (tok = @ss.scan /[a-z_$][-0-9a-z_$.]*\b/i)
@@ -135,172 +137,182 @@ end
135
137
  ##### State transition tables begin ###
136
138
 
137
139
  racc_action_table = [
138
- 15, 9, 16, 71, 68, 29, 67, 33, 66, 46,
139
- 69, 69, 31, 17, 47, 67, 18, 66, 48, 19,
140
- 20, 21, 22, 23, 44, 24, 25, 102, 98, 26,
141
- 27, 28, 75, 76, 40, 41, 97, 98, 61, 62,
142
- 49, 50, 51, 47, 52, 53, 54, 55, 56, 59,
143
- 59, 43, 63, 42, 39, 70, 45, 72, 73, 74,
144
- 38, 77, 59, 79, 80, 81, 82, 83, 33, 85,
145
- 86, 87, 88, 89, 91, 92, 93, 95, 96, 35,
146
- 99, 100, 95, 34 ]
140
+ 16, 9, 73, 70, 17, 69, 35, 68, 71, 71,
141
+ 33, 69, 31, 68, 18, 81, 82, 19, 81, 82,
142
+ 20, 21, 22, 23, 24, 56, 25, 26, 27, 42,
143
+ 43, 28, 29, 30, 81, 82, 81, 82, 101, 102,
144
+ 81, 82, 106, 102, 81, 82, 77, 78, 51, 52,
145
+ 81, 82, 81, 82, 63, 64, 57, 58, 61, 61,
146
+ 54, 65, 49, 53, 72, 55, 74, 75, 76, 50,
147
+ 79, 61, 49, 84, 85, 86, 87, 48, 89, 90,
148
+ 91, 47, 93, 46, 45, 44, 41, 100, 40, 103,
149
+ 35, 37, 36 ]
147
150
 
148
151
  racc_action_check = [
149
- 0, 0, 0, 60, 57, 1, 56, 16, 56, 30,
150
- 60, 57, 16, 0, 32, 76, 0, 76, 34, 0,
151
- 0, 0, 0, 0, 28, 0, 0, 101, 101, 0,
152
- 0, 0, 64, 64, 25, 25, 94, 94, 51, 51,
153
- 35, 35, 36, 37, 38, 39, 46, 47, 48, 49,
154
- 50, 27, 54, 26, 24, 59, 29, 61, 62, 63,
155
- 23, 68, 69, 70, 71, 72, 74, 75, 19, 77,
156
- 80, 81, 82, 83, 85, 86, 87, 89, 90, 18,
157
- 96, 98, 99, 17 ]
152
+ 0, 0, 62, 59, 0, 58, 17, 58, 62, 59,
153
+ 17, 78, 1, 78, 0, 89, 89, 0, 93, 93,
154
+ 0, 0, 0, 0, 0, 48, 0, 0, 0, 27,
155
+ 27, 0, 0, 0, 91, 91, 90, 90, 98, 98,
156
+ 86, 86, 105, 105, 72, 72, 66, 66, 37, 37,
157
+ 102, 102, 103, 103, 53, 53, 49, 50, 51, 52,
158
+ 40, 56, 39, 38, 61, 41, 63, 64, 65, 36,
159
+ 70, 71, 34, 73, 74, 76, 77, 32, 79, 84,
160
+ 85, 31, 87, 30, 29, 28, 26, 94, 24, 100,
161
+ 20, 19, 18 ]
158
162
 
159
163
  racc_action_pointer = [
160
- -1, 5, nil, nil, nil, nil, nil, nil, nil, nil,
161
- nil, nil, nil, nil, nil, nil, 2, 68, 74, 63,
162
- nil, nil, nil, 35, 29, 6, 48, 46, 19, 56,
163
- 5, nil, 1, nil, 13, 22, 38, 30, 39, 40,
164
- nil, nil, nil, nil, nil, nil, 41, 42, 37, 44,
165
- 45, 33, nil, nil, 46, nil, 1, -2, nil, 47,
166
- -3, 51, 51, 52, 20, nil, nil, nil, 54, 57,
167
- 54, 57, 58, nil, 58, 51, 10, 61, nil, nil,
168
- 62, 63, 63, 62, nil, 65, 66, 67, nil, 68,
169
- 65, nil, nil, nil, 24, nil, 69, nil, 72, 73,
170
- nil, 15, nil ]
164
+ -1, 12, nil, nil, nil, nil, nil, nil, nil, nil,
165
+ nil, nil, nil, nil, nil, nil, nil, -1, 76, 84,
166
+ 83, nil, nil, nil, 62, nil, 60, -1, 78, 77,
167
+ 76, 81, 71, nil, 58, nil, 62, 29, 57, 48,
168
+ 53, 58, nil, nil, nil, nil, nil, nil, 18, 49,
169
+ 45, 51, 52, 47, nil, nil, 53, nil, -2, -5,
170
+ nil, 54, -6, 58, 58, 59, 33, nil, nil, nil,
171
+ 61, 64, 41, 64, 65, nil, 65, 59, 4, 68,
172
+ nil, nil, nil, nil, 69, 70, 37, 70, nil, 12,
173
+ 33, 31, nil, 15, 73, nil, nil, nil, 25, nil,
174
+ 77, nil, 47, 49, nil, 29, nil ]
171
175
 
172
176
  racc_action_default = [
173
- -57, -57, -1, -2, -3, -4, -5, -6, -7, -8,
174
- -9, -10, -11, -12, -13, -14, -16, -57, -57, -41,
175
- -43, -44, -45, -57, -57, -57, -57, -57, -57, -57,
176
- -57, -17, -18, -53, -57, -57, -57, -42, -57, -57,
177
- -48, -49, -50, -51, -52, 103, -57, -57, -57, -57,
178
- -57, -57, -46, -47, -57, -54, -57, -27, -34, -57,
179
- -31, -38, -39, -57, -57, -22, -24, -25, -28, -57,
180
- -57, -32, -57, -40, -57, -57, -57, -29, -35, -36,
181
- -33, -57, -57, -57, -23, -57, -57, -57, -15, -57,
182
- -21, -26, -30, -37, -57, -55, -57, -19, -57, -57,
183
- -56, -57, -20 ]
177
+ -61, -61, -1, -2, -3, -4, -5, -6, -7, -8,
178
+ -9, -10, -11, -12, -13, -14, -15, -19, -61, -61,
179
+ -44, -46, -47, -48, -61, -50, -61, -61, -61, -61,
180
+ -61, -61, -61, -20, -21, -57, -61, -61, -61, -45,
181
+ -61, -61, -52, -53, -54, -55, -56, 107, -61, -61,
182
+ -61, -61, -61, -61, -49, -51, -61, -58, -61, -30,
183
+ -37, -61, -34, -41, -42, -61, -61, -25, -27, -28,
184
+ -31, -61, -61, -35, -61, -43, -61, -61, -61, -32,
185
+ -38, -16, -17, -39, -36, -61, -61, -61, -26, -61,
186
+ -61, -61, -18, -61, -24, -29, -33, -40, -61, -59,
187
+ -61, -22, -61, -61, -60, -61, -23 ]
184
188
 
185
189
  racc_goto_table = [
186
- 65, 94, 32, 57, 60, 37, 13, 6, 7, 8,
187
- 10, 101, 11, 12, 5, 14, 30, 1, 90, 4,
188
- 84, 64, 3, 2, 78, 36 ]
190
+ 83, 67, 98, 34, 59, 62, 39, 14, 7, 8,
191
+ 10, 11, 105, 12, 92, 13, 6, 95, 96, 97,
192
+ 15, 88, 1, 32, 5, 94, 4, 66, 3, 2,
193
+ 104, 80, 38 ]
189
194
 
190
195
  racc_goto_check = [
191
- 19, 17, 15, 20, 20, 15, 12, 6, 7, 8,
192
- 9, 17, 10, 11, 5, 13, 14, 1, 16, 4,
193
- 19, 18, 3, 2, 21, 22 ]
196
+ 15, 21, 19, 17, 22, 22, 17, 13, 7, 8,
197
+ 9, 10, 19, 11, 15, 12, 6, 15, 15, 15,
198
+ 14, 21, 1, 16, 5, 18, 4, 20, 3, 2,
199
+ 15, 23, 24 ]
194
200
 
195
201
  racc_goto_pointer = [
196
- nil, 17, 23, 22, 19, 14, 7, 8, 9, 10,
197
- 12, 13, 6, 15, 0, -14, -65, -88, -35, -56,
198
- -46, -45, 6 ]
202
+ nil, 22, 29, 28, 26, 24, 16, 8, 9, 10,
203
+ 11, 13, 15, 7, 20, -72, 6, -14, -62, -91,
204
+ -31, -57, -47, -40, 12 ]
199
205
 
200
206
  racc_goto_default = [
201
207
  nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
202
- nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
203
- nil, 58, nil ]
208
+ nil, nil, nil, nil, nil, 99, nil, nil, nil, nil,
209
+ nil, nil, nil, 60, nil ]
204
210
 
205
211
  racc_reduce_table = [
206
212
  0, 0, :racc_error,
207
- 1, 34, :_reduce_none,
208
- 1, 34, :_reduce_none,
209
- 1, 34, :_reduce_none,
210
- 1, 34, :_reduce_none,
211
- 1, 34, :_reduce_none,
212
- 1, 34, :_reduce_none,
213
- 1, 34, :_reduce_none,
214
- 1, 34, :_reduce_none,
215
- 1, 34, :_reduce_none,
216
- 1, 34, :_reduce_none,
217
- 1, 34, :_reduce_none,
218
- 1, 34, :_reduce_none,
219
- 1, 34, :_reduce_none,
220
- 1, 34, :_reduce_14,
221
- 8, 35, :_reduce_15,
222
- 0, 47, :_reduce_16,
223
- 1, 47, :_reduce_17,
224
- 1, 47, :_reduce_none,
225
- 3, 49, :_reduce_19,
226
- 5, 49, :_reduce_20,
227
- 8, 36, :_reduce_21,
228
- 1, 51, :_reduce_22,
229
- 3, 51, :_reduce_23,
230
- 1, 52, :_reduce_none,
231
- 1, 52, :_reduce_none,
232
- 8, 37, :_reduce_26,
233
- 4, 37, :_reduce_27,
234
- 5, 37, :_reduce_28,
235
- 6, 37, :_reduce_29,
236
- 8, 38, :_reduce_30,
237
- 4, 38, :_reduce_31,
238
- 5, 38, :_reduce_32,
239
- 6, 38, :_reduce_33,
240
- 1, 53, :_reduce_34,
241
- 3, 53, :_reduce_35,
242
- 3, 54, :_reduce_36,
243
- 8, 39, :_reduce_37,
244
- 4, 39, :_reduce_38,
245
- 4, 39, :_reduce_39,
246
- 5, 39, :_reduce_40,
247
- 0, 55, :_reduce_41,
248
- 1, 55, :_reduce_none,
249
- 1, 40, :_reduce_43,
250
- 1, 41, :_reduce_44,
251
- 1, 41, :_reduce_45,
252
- 3, 42, :_reduce_46,
253
- 3, 43, :_reduce_47,
254
- 2, 44, :_reduce_48,
255
- 2, 44, :_reduce_49,
256
- 2, 45, :_reduce_50,
257
- 2, 46, :_reduce_51,
258
- 2, 46, :_reduce_52,
259
- 1, 48, :_reduce_53,
260
- 3, 48, :_reduce_54,
261
- 1, 50, :_reduce_55,
262
- 3, 50, :_reduce_56 ]
263
-
264
- racc_reduce_n = 57
265
-
266
- racc_shift_n = 103
213
+ 1, 36, :_reduce_none,
214
+ 1, 36, :_reduce_none,
215
+ 1, 36, :_reduce_none,
216
+ 1, 36, :_reduce_none,
217
+ 1, 36, :_reduce_none,
218
+ 1, 36, :_reduce_none,
219
+ 1, 36, :_reduce_none,
220
+ 1, 36, :_reduce_none,
221
+ 1, 36, :_reduce_none,
222
+ 1, 36, :_reduce_none,
223
+ 1, 36, :_reduce_none,
224
+ 1, 36, :_reduce_none,
225
+ 1, 36, :_reduce_none,
226
+ 1, 36, :_reduce_none,
227
+ 1, 36, :_reduce_15,
228
+ 1, 50, :_reduce_none,
229
+ 1, 50, :_reduce_none,
230
+ 8, 37, :_reduce_18,
231
+ 0, 51, :_reduce_19,
232
+ 1, 51, :_reduce_20,
233
+ 1, 51, :_reduce_none,
234
+ 3, 53, :_reduce_22,
235
+ 5, 53, :_reduce_23,
236
+ 8, 38, :_reduce_24,
237
+ 1, 55, :_reduce_25,
238
+ 3, 55, :_reduce_26,
239
+ 1, 56, :_reduce_none,
240
+ 1, 56, :_reduce_none,
241
+ 8, 39, :_reduce_29,
242
+ 4, 39, :_reduce_30,
243
+ 5, 39, :_reduce_31,
244
+ 6, 39, :_reduce_32,
245
+ 8, 40, :_reduce_33,
246
+ 4, 40, :_reduce_34,
247
+ 5, 40, :_reduce_35,
248
+ 6, 40, :_reduce_36,
249
+ 1, 57, :_reduce_37,
250
+ 3, 57, :_reduce_38,
251
+ 3, 58, :_reduce_39,
252
+ 8, 41, :_reduce_40,
253
+ 4, 41, :_reduce_41,
254
+ 4, 41, :_reduce_42,
255
+ 5, 41, :_reduce_43,
256
+ 0, 59, :_reduce_44,
257
+ 1, 59, :_reduce_none,
258
+ 1, 42, :_reduce_46,
259
+ 1, 43, :_reduce_47,
260
+ 1, 43, :_reduce_48,
261
+ 3, 45, :_reduce_49,
262
+ 1, 44, :_reduce_50,
263
+ 3, 46, :_reduce_51,
264
+ 2, 47, :_reduce_52,
265
+ 2, 47, :_reduce_53,
266
+ 2, 48, :_reduce_54,
267
+ 2, 49, :_reduce_55,
268
+ 2, 49, :_reduce_56,
269
+ 1, 52, :_reduce_57,
270
+ 3, 52, :_reduce_58,
271
+ 1, 54, :_reduce_59,
272
+ 3, 54, :_reduce_60 ]
273
+
274
+ racc_reduce_n = 61
275
+
276
+ racc_shift_n = 107
267
277
 
268
278
  racc_token_table = {
269
279
  false => 0,
270
280
  :error => 1,
271
281
  :current_stmt => 2,
272
- :GET => 3,
273
- :FROM => 4,
274
- :IDENTIFIER => 5,
275
- :WHERE => 6,
276
- :ITEMNAME => 7,
277
- "=" => 8,
278
- :VALUE => 9,
279
- "*" => 10,
280
- "(" => 11,
281
- ")" => 12,
282
- "," => 13,
283
- :INSERT => 14,
284
- :INTO => 15,
285
- :VALUES => 16,
286
- :UPDATE => 17,
287
- :SET => 18,
288
- :ADD => 19,
289
- :DELETE => 20,
290
- :SELECT => 21,
291
- :NEXT => 22,
292
- :CURRENT => 23,
293
- :CREATE => 24,
294
- :DOMAIN => 25,
295
- :DROP => 26,
296
- :SHOW => 27,
297
- :DOMAINS => 28,
298
- :REGIONS => 29,
299
- :USE => 30,
300
- :DESC => 31,
301
- :DESCRIBE => 32 }
302
-
303
- racc_nt_base = 33
282
+ :STRING => 3,
283
+ :NUMBER => 4,
284
+ :GET => 5,
285
+ :FROM => 6,
286
+ :IDENTIFIER => 7,
287
+ :WHERE => 8,
288
+ :ITEMNAME => 9,
289
+ "=" => 10,
290
+ "*" => 11,
291
+ "(" => 12,
292
+ ")" => 13,
293
+ "," => 14,
294
+ :INSERT => 15,
295
+ :INTO => 16,
296
+ :VALUES => 17,
297
+ :UPDATE => 18,
298
+ :SET => 19,
299
+ :ADD => 20,
300
+ :DELETE => 21,
301
+ :SELECT => 22,
302
+ :NEXT => 23,
303
+ :CURRENT => 24,
304
+ :CREATE => 25,
305
+ :DOMAIN => 26,
306
+ :PAGE => 27,
307
+ :DROP => 28,
308
+ :SHOW => 29,
309
+ :DOMAINS => 30,
310
+ :REGIONS => 31,
311
+ :USE => 32,
312
+ :DESC => 33,
313
+ :DESCRIBE => 34 }
314
+
315
+ racc_nt_base = 35
304
316
 
305
317
  racc_use_result_var = false
306
318
 
@@ -324,13 +336,14 @@ Racc_token_to_s_table = [
324
336
  "$end",
325
337
  "error",
326
338
  "current_stmt",
339
+ "STRING",
340
+ "NUMBER",
327
341
  "GET",
328
342
  "FROM",
329
343
  "IDENTIFIER",
330
344
  "WHERE",
331
345
  "ITEMNAME",
332
346
  "\"=\"",
333
- "VALUE",
334
347
  "\"*\"",
335
348
  "\"(\"",
336
349
  "\")\"",
@@ -347,6 +360,7 @@ Racc_token_to_s_table = [
347
360
  "CURRENT",
348
361
  "CREATE",
349
362
  "DOMAIN",
363
+ "PAGE",
350
364
  "DROP",
351
365
  "SHOW",
352
366
  "DOMAINS",
@@ -363,11 +377,13 @@ Racc_token_to_s_table = [
363
377
  "delete_stmt",
364
378
  "select_stmt",
365
379
  "next_stmt",
380
+ "page_stmt",
366
381
  "create_stmt",
367
382
  "drop_stmt",
368
383
  "show_stmt",
369
384
  "use_stmt",
370
385
  "desc_stmt",
386
+ "value",
371
387
  "get_output_list",
372
388
  "identifier_list",
373
389
  "value_list_list",
@@ -410,52 +426,58 @@ Racc_debug_parser = false
410
426
 
411
427
  # reduce 13 omitted
412
428
 
413
- module_eval(<<'.,.,', 'sdb-parser.y', 18)
414
- def _reduce_14(val, _values)
429
+ # reduce 14 omitted
430
+
431
+ module_eval(<<'.,.,', 'sdb-parser.y', 19)
432
+ def _reduce_15(val, _values)
415
433
  @stmt_with_expr
416
434
 
417
435
  end
418
436
  .,.,
419
437
 
420
- module_eval(<<'.,.,', 'sdb-parser.y', 23)
421
- def _reduce_15(val, _values)
438
+ # reduce 16 omitted
439
+
440
+ # reduce 17 omitted
441
+
442
+ module_eval(<<'.,.,', 'sdb-parser.y', 27)
443
+ def _reduce_18(val, _values)
422
444
  struct(:GET, :domain => val[3], :item_name => val[7], :attr_names => val[1])
423
445
 
424
446
  end
425
447
  .,.,
426
448
 
427
- module_eval(<<'.,.,', 'sdb-parser.y', 28)
428
- def _reduce_16(val, _values)
449
+ module_eval(<<'.,.,', 'sdb-parser.y', 32)
450
+ def _reduce_19(val, _values)
429
451
  []
430
452
 
431
453
  end
432
454
  .,.,
433
455
 
434
- module_eval(<<'.,.,', 'sdb-parser.y', 32)
435
- def _reduce_17(val, _values)
456
+ module_eval(<<'.,.,', 'sdb-parser.y', 36)
457
+ def _reduce_20(val, _values)
436
458
  []
437
459
 
438
460
  end
439
461
  .,.,
440
462
 
441
- # reduce 18 omitted
463
+ # reduce 21 omitted
442
464
 
443
- module_eval(<<'.,.,', 'sdb-parser.y', 38)
444
- def _reduce_19(val, _values)
465
+ module_eval(<<'.,.,', 'sdb-parser.y', 42)
466
+ def _reduce_22(val, _values)
445
467
  [val[1]]
446
468
 
447
469
  end
448
470
  .,.,
449
471
 
450
- module_eval(<<'.,.,', 'sdb-parser.y', 42)
451
- def _reduce_20(val, _values)
472
+ module_eval(<<'.,.,', 'sdb-parser.y', 46)
473
+ def _reduce_23(val, _values)
452
474
  val[0] + [val[3]]
453
475
 
454
476
  end
455
477
  .,.,
456
478
 
457
- module_eval(<<'.,.,', 'sdb-parser.y', 47)
458
- def _reduce_21(val, _values)
479
+ module_eval(<<'.,.,', 'sdb-parser.y', 51)
480
+ def _reduce_24(val, _values)
459
481
  items = val[7].map do |vals|
460
482
  unless val[4].length == vals.length
461
483
  raise Racc::ParseError, 'The number of an attribute and values differs'
@@ -480,26 +502,26 @@ module_eval(<<'.,.,', 'sdb-parser.y', 47)
480
502
  end
481
503
  .,.,
482
504
 
483
- module_eval(<<'.,.,', 'sdb-parser.y', 71)
484
- def _reduce_22(val, _values)
505
+ module_eval(<<'.,.,', 'sdb-parser.y', 75)
506
+ def _reduce_25(val, _values)
485
507
  [val[0]]
486
508
 
487
509
  end
488
510
  .,.,
489
511
 
490
- module_eval(<<'.,.,', 'sdb-parser.y', 75)
491
- def _reduce_23(val, _values)
512
+ module_eval(<<'.,.,', 'sdb-parser.y', 79)
513
+ def _reduce_26(val, _values)
492
514
  val[0] + [val[2]]
493
515
 
494
516
  end
495
517
  .,.,
496
518
 
497
- # reduce 24 omitted
519
+ # reduce 27 omitted
498
520
 
499
- # reduce 25 omitted
521
+ # reduce 28 omitted
500
522
 
501
- module_eval(<<'.,.,', 'sdb-parser.y', 83)
502
- def _reduce_26(val, _values)
523
+ module_eval(<<'.,.,', 'sdb-parser.y', 87)
524
+ def _reduce_29(val, _values)
503
525
  attrs = {}
504
526
  val[3].each {|k, v| attrs[k] = v }
505
527
  struct(:UPDATE, :domain => val[1], :items => [[val[7], attrs]])
@@ -507,8 +529,8 @@ module_eval(<<'.,.,', 'sdb-parser.y', 83)
507
529
  end
508
530
  .,.,
509
531
 
510
- module_eval(<<'.,.,', 'sdb-parser.y', 89)
511
- def _reduce_27(val, _values)
532
+ module_eval(<<'.,.,', 'sdb-parser.y', 93)
533
+ def _reduce_30(val, _values)
512
534
  attrs = {}
513
535
  val[3].each {|k, v| attrs[k] = v }
514
536
  @stmt_with_expr = struct(:UPDATE_WITH_EXPR, :domain => val[1], :attrs => attrs, :expr => '')
@@ -516,8 +538,8 @@ module_eval(<<'.,.,', 'sdb-parser.y', 89)
516
538
  end
517
539
  .,.,
518
540
 
519
- module_eval(<<'.,.,', 'sdb-parser.y', 95)
520
- def _reduce_28(val, _values)
541
+ module_eval(<<'.,.,', 'sdb-parser.y', 99)
542
+ def _reduce_31(val, _values)
521
543
  attrs = {}
522
544
  val[3].each {|k, v| attrs[k] = v }
523
545
  @stmt_with_expr = struct(:UPDATE_WITH_EXPR, :domain => val[1], :attrs => attrs, :expr => 'WHERE ')
@@ -525,8 +547,8 @@ module_eval(<<'.,.,', 'sdb-parser.y', 95)
525
547
  end
526
548
  .,.,
527
549
 
528
- module_eval(<<'.,.,', 'sdb-parser.y', 101)
529
- def _reduce_29(val, _values)
550
+ module_eval(<<'.,.,', 'sdb-parser.y', 105)
551
+ def _reduce_32(val, _values)
530
552
  attrs = {}
531
553
  val[3].each {|k, v| attrs[k] = v }
532
554
  @stmt_with_expr = struct(:UPDATE_WITH_EXPR, :domain => val[1], :attrs => attrs, :expr => 'WHERE itemName')
@@ -534,8 +556,8 @@ module_eval(<<'.,.,', 'sdb-parser.y', 101)
534
556
  end
535
557
  .,.,
536
558
 
537
- module_eval(<<'.,.,', 'sdb-parser.y', 108)
538
- def _reduce_30(val, _values)
559
+ module_eval(<<'.,.,', 'sdb-parser.y', 112)
560
+ def _reduce_33(val, _values)
539
561
  attrs = {}
540
562
  val[3].each {|k, v| attrs[k] = v }
541
563
  struct(:MERGE, :domain => val[1], :items => [[val[7], attrs]])
@@ -543,8 +565,8 @@ module_eval(<<'.,.,', 'sdb-parser.y', 108)
543
565
  end
544
566
  .,.,
545
567
 
546
- module_eval(<<'.,.,', 'sdb-parser.y', 114)
547
- def _reduce_31(val, _values)
568
+ module_eval(<<'.,.,', 'sdb-parser.y', 118)
569
+ def _reduce_34(val, _values)
548
570
  attrs = {}
549
571
  val[3].each {|k, v| attrs[k] = v }
550
572
  @stmt_with_expr = struct(:MERGE_WITH_EXPR, :domain => val[1], :attrs => attrs, :expr => '')
@@ -552,8 +574,8 @@ module_eval(<<'.,.,', 'sdb-parser.y', 114)
552
574
  end
553
575
  .,.,
554
576
 
555
- module_eval(<<'.,.,', 'sdb-parser.y', 120)
556
- def _reduce_32(val, _values)
577
+ module_eval(<<'.,.,', 'sdb-parser.y', 124)
578
+ def _reduce_35(val, _values)
557
579
  attrs = {}
558
580
  val[3].each {|k, v| attrs[k] = v }
559
581
  @stmt_with_expr = struct(:MERGE_WITH_EXPR, :domain => val[1], :attrs => attrs, :expr => 'WHERE ')
@@ -561,8 +583,8 @@ module_eval(<<'.,.,', 'sdb-parser.y', 120)
561
583
  end
562
584
  .,.,
563
585
 
564
- module_eval(<<'.,.,', 'sdb-parser.y', 126)
565
- def _reduce_33(val, _values)
586
+ module_eval(<<'.,.,', 'sdb-parser.y', 130)
587
+ def _reduce_36(val, _values)
566
588
  attrs = {}
567
589
  val[3].each {|k, v| attrs[k] = v }
568
590
  @stmt_with_expr = struct(:MERGE_WITH_EXPR, :domain => val[1], :attrs => attrs, :expr => 'WHERE itemName')
@@ -570,73 +592,73 @@ module_eval(<<'.,.,', 'sdb-parser.y', 126)
570
592
  end
571
593
  .,.,
572
594
 
573
- module_eval(<<'.,.,', 'sdb-parser.y', 133)
574
- def _reduce_34(val, _values)
595
+ module_eval(<<'.,.,', 'sdb-parser.y', 137)
596
+ def _reduce_37(val, _values)
575
597
  [val[0]]
576
598
 
577
599
  end
578
600
  .,.,
579
601
 
580
- module_eval(<<'.,.,', 'sdb-parser.y', 137)
581
- def _reduce_35(val, _values)
602
+ module_eval(<<'.,.,', 'sdb-parser.y', 141)
603
+ def _reduce_38(val, _values)
582
604
  val[0] + [val[2]]
583
605
 
584
606
  end
585
607
  .,.,
586
608
 
587
- module_eval(<<'.,.,', 'sdb-parser.y', 142)
588
- def _reduce_36(val, _values)
609
+ module_eval(<<'.,.,', 'sdb-parser.y', 146)
610
+ def _reduce_39(val, _values)
589
611
  [val[0], val[2]]
590
612
 
591
613
  end
592
614
  .,.,
593
615
 
594
- module_eval(<<'.,.,', 'sdb-parser.y', 147)
595
- def _reduce_37(val, _values)
616
+ module_eval(<<'.,.,', 'sdb-parser.y', 151)
617
+ def _reduce_40(val, _values)
596
618
  struct(:DELETE, :domain => val[3], :items => [[val[7], val[1]]])
597
619
 
598
620
  end
599
621
  .,.,
600
622
 
601
- module_eval(<<'.,.,', 'sdb-parser.y', 151)
602
- def _reduce_38(val, _values)
623
+ module_eval(<<'.,.,', 'sdb-parser.y', 155)
624
+ def _reduce_41(val, _values)
603
625
  @stmt_with_expr = struct(:DELETE_WITH_EXPR, :domain => val[3], :attrs => val[1], :expr => '')
604
626
 
605
627
  end
606
628
  .,.,
607
629
 
608
- module_eval(<<'.,.,', 'sdb-parser.y', 155)
609
- def _reduce_39(val, _values)
630
+ module_eval(<<'.,.,', 'sdb-parser.y', 159)
631
+ def _reduce_42(val, _values)
610
632
  @stmt_with_expr = struct(:DELETE_WITH_EXPR, :domain => val[3], :attrs => val[1], :expr => 'WHERE ')
611
633
 
612
634
  end
613
635
  .,.,
614
636
 
615
- module_eval(<<'.,.,', 'sdb-parser.y', 159)
616
- def _reduce_40(val, _values)
637
+ module_eval(<<'.,.,', 'sdb-parser.y', 163)
638
+ def _reduce_43(val, _values)
617
639
  @stmt_with_expr = struct(:DELETE_WITH_EXPR, :domain => val[3], :attrs => val[1], :expr => 'WHERE itemName')
618
640
 
619
641
  end
620
642
  .,.,
621
643
 
622
- module_eval(<<'.,.,', 'sdb-parser.y', 164)
623
- def _reduce_41(val, _values)
644
+ module_eval(<<'.,.,', 'sdb-parser.y', 168)
645
+ def _reduce_44(val, _values)
624
646
  []
625
647
 
626
648
  end
627
649
  .,.,
628
650
 
629
- # reduce 42 omitted
651
+ # reduce 45 omitted
630
652
 
631
- module_eval(<<'.,.,', 'sdb-parser.y', 170)
632
- def _reduce_43(val, _values)
653
+ module_eval(<<'.,.,', 'sdb-parser.y', 174)
654
+ def _reduce_46(val, _values)
633
655
  query = ''
634
656
  ruby = nil
635
657
 
636
658
  ss = StringScanner.new(val[0])
637
659
 
638
660
  until ss.eos?
639
- if (tok = ss.scan %r{[^-`'";\\/#|]+}) #'
661
+ if (tok = ss.scan /[^`'"|]+/) #'
640
662
  query << tok
641
663
  elsif (tok = ss.scan /`(?:[^`]|``)*`/)
642
664
  query << tok
@@ -656,94 +678,103 @@ module_eval(<<'.,.,', 'sdb-parser.y', 170)
656
678
  end
657
679
  .,.,
658
680
 
659
- module_eval(<<'.,.,', 'sdb-parser.y', 196)
660
- def _reduce_44(val, _values)
681
+ module_eval(<<'.,.,', 'sdb-parser.y', 200)
682
+ def _reduce_47(val, _values)
661
683
  ruby = val[0].sub(/\A\s*\|\s*/, '') if val[0]
662
684
  struct(:NEXT, :ruby => ruby)
663
685
 
664
686
  end
665
687
  .,.,
666
688
 
667
- module_eval(<<'.,.,', 'sdb-parser.y', 202)
668
- def _reduce_45(val, _values)
689
+ module_eval(<<'.,.,', 'sdb-parser.y', 206)
690
+ def _reduce_48(val, _values)
669
691
  ruby = val[0].sub(/\A\s*\|\s*/, '') if val[0]
670
692
  struct(:CURRENT, :ruby => ruby)
671
693
 
672
694
  end
673
695
  .,.,
674
696
 
675
- module_eval(<<'.,.,', 'sdb-parser.y', 208)
676
- def _reduce_46(val, _values)
697
+ module_eval(<<'.,.,', 'sdb-parser.y', 212)
698
+ def _reduce_49(val, _values)
677
699
  struct(:CREATE, :domain => val[2])
678
700
 
679
701
  end
680
702
  .,.,
681
703
 
682
- module_eval(<<'.,.,', 'sdb-parser.y', 213)
683
- def _reduce_47(val, _values)
704
+ module_eval(<<'.,.,', 'sdb-parser.y', 217)
705
+ def _reduce_50(val, _values)
706
+ page, ruby = val[0].split(/\s*\|\s*/, 2)
707
+ page = page.split(/\s+/, 2).last.strip.to_i
708
+ struct(:PAGE, :page => page, :ruby => ruby)
709
+
710
+ end
711
+ .,.,
712
+
713
+ module_eval(<<'.,.,', 'sdb-parser.y', 224)
714
+ def _reduce_51(val, _values)
684
715
  struct(:DROP, :domain => val[2])
685
716
 
686
717
  end
687
718
  .,.,
688
719
 
689
- module_eval(<<'.,.,', 'sdb-parser.y', 218)
690
- def _reduce_48(val, _values)
720
+ module_eval(<<'.,.,', 'sdb-parser.y', 229)
721
+ def _reduce_52(val, _values)
691
722
  struct(:SHOW, :operand => :domains)
692
723
 
693
724
  end
694
725
  .,.,
695
726
 
696
- module_eval(<<'.,.,', 'sdb-parser.y', 222)
697
- def _reduce_49(val, _values)
727
+ module_eval(<<'.,.,', 'sdb-parser.y', 233)
728
+ def _reduce_53(val, _values)
698
729
  struct(:SHOW, :operand => :regions)
699
730
 
700
731
  end
701
732
  .,.,
702
733
 
703
- module_eval(<<'.,.,', 'sdb-parser.y', 226)
704
- def _reduce_50(val, _values)
734
+ module_eval(<<'.,.,', 'sdb-parser.y', 237)
735
+ def _reduce_54(val, _values)
705
736
  struct(:USE, :endpoint => val[1])
706
737
 
707
738
  end
708
739
  .,.,
709
740
 
710
- module_eval(<<'.,.,', 'sdb-parser.y', 230)
711
- def _reduce_51(val, _values)
741
+ module_eval(<<'.,.,', 'sdb-parser.y', 241)
742
+ def _reduce_55(val, _values)
712
743
  struct(:DESCRIBE, :domain => val[1])
713
744
 
714
745
  end
715
746
  .,.,
716
747
 
717
- module_eval(<<'.,.,', 'sdb-parser.y', 234)
718
- def _reduce_52(val, _values)
748
+ module_eval(<<'.,.,', 'sdb-parser.y', 245)
749
+ def _reduce_56(val, _values)
719
750
  struct(:DESCRIBE, :domain => val[1])
720
751
 
721
752
  end
722
753
  .,.,
723
754
 
724
- module_eval(<<'.,.,', 'sdb-parser.y', 239)
725
- def _reduce_53(val, _values)
755
+ module_eval(<<'.,.,', 'sdb-parser.y', 250)
756
+ def _reduce_57(val, _values)
726
757
  [val[0]]
727
758
 
728
759
  end
729
760
  .,.,
730
761
 
731
- module_eval(<<'.,.,', 'sdb-parser.y', 243)
732
- def _reduce_54(val, _values)
762
+ module_eval(<<'.,.,', 'sdb-parser.y', 254)
763
+ def _reduce_58(val, _values)
733
764
  val[0] + [val[2]]
734
765
 
735
766
  end
736
767
  .,.,
737
768
 
738
- module_eval(<<'.,.,', 'sdb-parser.y', 248)
739
- def _reduce_55(val, _values)
769
+ module_eval(<<'.,.,', 'sdb-parser.y', 259)
770
+ def _reduce_59(val, _values)
740
771
  [val[0]]
741
772
 
742
773
  end
743
774
  .,.,
744
775
 
745
- module_eval(<<'.,.,', 'sdb-parser.y', 252)
746
- def _reduce_56(val, _values)
776
+ module_eval(<<'.,.,', 'sdb-parser.y', 263)
777
+ def _reduce_60(val, _values)
747
778
  [val[0], val[2]].flatten
748
779
 
749
780
  end
data/lib/sdbcli/sdb-parser.y CHANGED
@@ -9,6 +9,7 @@ rule
9
9
  | select_stmt
10
10
  | next_stmt
11
11
  | current_stmt
12
+ | page_stmt
12
13
  | create_stmt
13
14
  | drop_stmt
14
15
  | show_stmt
@@ -19,7 +20,10 @@ rule
19
20
  @stmt_with_expr
20
21
  }
21
22
 
22
- get_stmt : GET get_output_list FROM IDENTIFIER WHERE ITEMNAME '=' VALUE
23
+ value : STRING
24
+ | NUMBER
25
+
26
+ get_stmt : GET get_output_list FROM IDENTIFIER WHERE ITEMNAME '=' value
23
27
  {
24
28
  struct(:GET, :domain => val[3], :item_name => val[7], :attr_names => val[1])
25
29
  }
@@ -79,7 +83,7 @@ rule
79
83
  itemname_identifier : ITEMNAME
80
84
  | IDENTIFIER
81
85
 
82
- update_stmt : UPDATE IDENTIFIER SET set_clause_list WHERE ITEMNAME '=' VALUE
86
+ update_stmt : UPDATE IDENTIFIER SET set_clause_list WHERE ITEMNAME '=' value
83
87
  {
84
88
  attrs = {}
85
89
  val[3].each {|k, v| attrs[k] = v }
@@ -104,7 +108,7 @@ rule
104
108
  @stmt_with_expr = struct(:UPDATE_WITH_EXPR, :domain => val[1], :attrs => attrs, :expr => 'WHERE itemName')
105
109
  }
106
110
 
107
- merge_stmt : UPDATE IDENTIFIER ADD set_clause_list WHERE ITEMNAME '=' VALUE
111
+ merge_stmt : UPDATE IDENTIFIER ADD set_clause_list WHERE ITEMNAME '=' value
108
112
  {
109
113
  attrs = {}
110
114
  val[3].each {|k, v| attrs[k] = v }
@@ -138,12 +142,12 @@ rule
138
142
  val[0] + [val[2]]
139
143
  }
140
144
 
141
- set_clause : IDENTIFIER '=' VALUE
145
+ set_clause : IDENTIFIER '=' value
142
146
  {
143
147
  [val[0], val[2]]
144
148
  }
145
149
 
146
- delete_stmt : DELETE delete_attr_list FROM IDENTIFIER WHERE ITEMNAME '=' VALUE
150
+ delete_stmt : DELETE delete_attr_list FROM IDENTIFIER WHERE ITEMNAME '=' value
147
151
  {
148
152
  struct(:DELETE, :domain => val[3], :items => [[val[7], val[1]]])
149
153
  }
@@ -174,7 +178,7 @@ rule
174
178
  ss = StringScanner.new(val[0])
175
179
 
176
180
  until ss.eos?
177
- if (tok = ss.scan %r{[^-`'";\\/#|]+}) #'
181
+ if (tok = ss.scan /[^`'"|]+/) #'
178
182
  query << tok
179
183
  elsif (tok = ss.scan /`(?:[^`]|``)*`/)
180
184
  query << tok
@@ -209,6 +213,13 @@ rule
209
213
  struct(:CREATE, :domain => val[2])
210
214
  }
211
215
 
216
+ page_stmt : PAGE
217
+ {
218
+ page, ruby = val[0].split(/\s*\|\s*/, 2)
219
+ page = page.split(/\s+/, 2).last.strip.to_i
220
+ struct(:PAGE, :page => page, :ruby => ruby)
221
+ }
222
+
212
223
  drop_stmt : DROP DOMAIN IDENTIFIER
213
224
  {
214
225
  struct(:DROP, :domain => val[2])
@@ -244,11 +255,11 @@ rule
244
255
  val[0] + [val[2]]
245
256
  }
246
257
 
247
- value_list : VALUE
258
+ value_list : value
248
259
  {
249
260
  [val[0]]
250
261
  }
251
- | value_list ',' VALUE
262
+ | value_list ',' value
252
263
  {
253
264
  [val[0], val[2]].flatten
254
265
  }
@@ -338,16 +349,18 @@ def scan
338
349
  yield [:NEXT, @ss.scan(/\s*\|\s*.*/)]
339
350
  elsif (tok = @ss.scan /CUR(RENT)?\b/i)
340
351
  yield [:CURRENT, @ss.scan(/\s*\|\s*.*/)]
352
+ elsif (tok = @ss.scan /PAGE\s+\d+/i)
353
+ yield [:PAGE, tok + @ss.scan(/(\s*\|\s*.*)?/)]
341
354
  elsif (tok = @ss.scan /NULL\b/i)
342
355
  yield [:NULL, nil]
343
356
  elsif (tok = @ss.scan /`([^`]|``)*`/)
344
357
  yield [:IDENTIFIER, tok.slice(1...-1).gsub(/``/, '`')]
345
358
  elsif (tok = @ss.scan /'([^']|'')*'/) #'
346
- yield [:VALUE, tok.slice(1...-1).gsub(/''/, "'")]
359
+ yield [:STRING, tok.slice(1...-1).gsub(/''/, "'")]
347
360
  elsif (tok = @ss.scan /"([^"]|"")*"/) #"
348
- yield [:VALUE, tok.slice(1...-1).gsub(/""/, '"')]
361
+ yield [:STRING, tok.slice(1...-1).gsub(/""/, '"')]
349
362
  elsif (tok = @ss.scan /\d+(\.\d+)?/)
350
- yield [:VALUE, tok]
363
+ yield [:NUMBER, tok]
351
364
  elsif (tok = @ss.scan /[,\(\)\*]/)
352
365
  yield [tok, tok]
353
366
  elsif (tok = @ss.scan /[a-z_$][-0-9a-z_$.]*\b/i)
data/lib/sdbcli/sdb-runner.rb CHANGED
@@ -132,7 +132,7 @@ module SimpleDB
132
132
  rownum = items.length
133
133
  @driver.delete(parsed.domain, items)
134
134
  Rownum.new(rownum)
135
- when :SELECT, :NEXT, :CURRENT
135
+ when :SELECT, :NEXT, :CURRENT, :PAGE
136
136
  items = case command
137
137
  when :SELECT
138
138
  @driver.select(parsed.query, consistent, true)
@@ -140,6 +140,8 @@ module SimpleDB
140
140
  @driver.next_list(consistent)
141
141
  when :CURRENT
142
142
  @driver.current_list(consistent)
143
+ when :PAGE
144
+ @driver.page_to(parsed.page, consistent)
143
145
  else
144
146
  raise 'must not happen'
145
147
  end
@@ -168,7 +170,7 @@ module SimpleDB
168
170
  begin
169
171
  items = items.instance_eval(parsed.ruby.strip)
170
172
  rescue SyntaxError => e
171
- raise e.message
173
+ raise SimpleDB::Error, e.message
172
174
  end
173
175
  end
174
176
 
data/lib/sdbcli/sdb-token-generator.rb ADDED
@@ -0,0 +1,57 @@
1
+ # original code:
2
+ # http://d.hatena.ne.jp/tottokug/20120810/1344611039
3
+ module SimpleDB
4
+ class TokenGenerator
5
+
6
+ BASE_STRING = %w(
7
+ 101011001110110100000000000001010111001101110010000000000010011101100011011011110110110100101110
8
+ 011000010110110101100001011110100110111101101110001011100111001101100100011100110010111001010001
9
+ 011101010110010101110010011110010101000001110010011011110110001101100101011100110111001101101111
10
+ 011100100010111001001101011011110111001001100101010101000110111101101011011001010110111011101011
11
+ 011010011100010111001011100111001000001101001101101010110000001100000000000010110100100100000000
12
+ 000101000110100101101110011010010111010001101001011000010110110001000011011011110110111001101010
13
+ 011101010110111001100011011101000100100101101110011001000110010101111000010110100000000000001110
14
+ 011010010111001101010000011000010110011101100101010000100110111101110101011011100110010001100001
15
+ 011100100111100101001010000000000000110001101100011000010111001101110100010001010110111001110100
16
+ 011010010111010001111001010010010100010001011010000000000000101001101100011100100111000101000101
17
+ 011011100110000101100010011011000110010101100100010010010000000000001111011100010111010101100101
18
+ 011100100111100101000011011011110110110101110000011011000110010101111000011010010111010001111001
19
+ 010010100000000000010011011100010111010101100101011100100111100101010011011101000111001001101001
20
+ 011011100110011101000011011010000110010101100011011010110111001101110101011011010100100100000000
21
+ 000010100111010101101110011010010110111101101110010010010110111001100100011001010111100001011010
22
+ 000000000000110101110101011100110110010101010001011101010110010101110010011110010100100101101110
23
+ 011001000110010101111000010011000000000000001101011000110110111101101110011100110110100101110011
24
+ 011101000110010101101110011101000100110001010011010011100111010000000000000100100100110001101010
25
+ 011000010111011001100001001011110110110001100001011011100110011100101111010100110111010001110010
26
+ 011010010110111001100111001110110100110000000000000100100110110001100001011100110111010001000001
27
+ 011101000111010001110010011010010110001001110101011101000110010101010110011000010110110001110101
28
+ 011001010111000100000000011111100000000000000001010011000000000000001001011100110110111101110010
29
+ 011101000100111101110010011001000110010101110010011101000000000000101111010011000110001101101111
30
+ 011011010010111101100001011011010110000101111010011011110110111000101111011100110110010001110011
31
+ 001011110101000101110101011001010111001001111001010100000111001001101111011000110110010101110011
32
+ 011100110110111101110010001011110101000101110101011001010111001001111001001001000101001101101111
33
+ 011100100111010001001111011100100110010001100101011100100011101101111000011100000000000000000000
34
+ 000000000000000000000000
35
+ %064d
36
+ 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
37
+ 00000000000000000000000000000000000000000000000001110000011100000111000001111000
38
+ ).join
39
+
40
+ CODE_TABLE = Hash[
41
+ *(0b000000..0b111111).map {|i| '%06d' % i.to_s(2) }.zip(
42
+ ('A'..'Z').to_a +
43
+ ('a'..'z').to_a +
44
+ ('0'..'9').to_a +
45
+ ['+', '/']
46
+ ).flatten]
47
+
48
+ def self.next_token(limit, page)
49
+ offset = limit * (page - 1)
50
+ base = BASE_STRING % offset.to_s(2)
51
+
52
+ base.scan(/.{6}/).map {|bits|
53
+ CODE_TABLE[bits]
54
+ }.join
55
+ end
56
+ end
57
+ end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: sdbcli
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.3.6
4
+ version: 1.4.0
5
5
  prerelease:
6
6
  platform: ruby
7
7
  authors:
@@ -57,6 +57,7 @@ files:
57
57
  - lib/sdbcli/sdb-parser.tab.rb
58
58
  - lib/sdbcli/sdb-parser.y
59
59
  - lib/sdbcli/sdb-runner.rb
60
+ - lib/sdbcli/sdb-token-generator.rb
60
61
  - lib/sdbcli.rb
61
62
  homepage: https://bitbucket.org/winebarrel/sdbcli
62
63
  licenses: []