Class: YqlQuery::Builder

Inherits:
Object
  • Object
show all
Defined in:
lib/yql_query/builder.rb

Overview

The primary query builder class, wraps a Query object and provides methods to assign query arguments.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Builder

Instantiates a new Builder instance.

Parameters:



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/yql_query/builder.rb', line 10

def initialize(options={})
  self.query = Query.new
  self.query.table          = options.delete(:table)
  self.query.limit          = options.delete(:limit)
  self.query.offset         = options.delete(:offset)
  self.query.select         = options.delete(:select)
  self.query.conditions     = options.delete(:conditions) || []
  self.query.uses           = options.delete(:uses) || []
  self.query.tail           = options.delete(:tail)
  self.query.truncate       = options.delete(:truncate)
  self.query.reverse        = options.delete(:reverse)
  self.query.unique         = options.delete(:unique)
  self.query.sanitize       = options.delete(:sanitize)
  self.query.remote_limit   = options.delete(:remote_limit)
  self.query.remote_offset  = options.delete(:remote_offset)
end

Instance Attribute Details

#query ⇒ Object

Returns the value of attribute query.



6
7
8
 
# File 'lib/yql_query/builder.rb', line 6

def query
  @query
end

Instance Method Details

#conditions(conditions) ⇒ YqlQuery::Builder Also known as: where

Assigns additional datatable sources for use with the query being constructed. Conditions are combined. Hashes assume equivalency when generating queries, except when passed a YqlQuery::Builder instance in which case a sub-select is assumed using an ‘in’.

Examples:

The conditions may be passed as either a string, array or a hash:

base = Builder.new.conditions("sub_genre = 'bebop'")
base.to_s
# => "select * from tablename where sub_genre = 'bebop'"

base.conditions("genre = 'jazz'").conditions("sub_genre = 'bebop'")
base.to_s
# => "select * from tablename where genre = 'jazz' and sub_genre = 'bebop'"

base.conditions(["genre = 'jazz'", "sub_genre = 'bebop'"])
# => "select * from tablename where genre = 'jazz' and sub_genre = 'bebop'"

# conditions are also aliased as 'where'
base.where("genre = 'jazz'")

guid_query = Builder.new.table('users').select('guid').where("role = 'admin'")
base = Builder.new.table('actions).where(:guid => guid_query)
base.to_s
=> "select * from actions where guid in (select guid from users where role = 'admin')"

Parameters:

  • conditions (Objct) —

    The conditions of the query.

Returns:

  • (YqlQuery::Builder) —

    YqlQuery::Builder instance reflecting the data conditions assigned.



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/yql_query/builder.rb', line 132

def conditions(conditions)
  if conditions.kind_of?(String)
    self.query.conditions << conditions
  elsif conditions.kind_of?(Array)
    self.query.conditions += conditions
  elsif conditions.kind_of?(Hash)
    conditions.each do |key, value|
      if value.kind_of?(YqlQuery::Builder)
        self.query.conditions << "#{key} in (#{value})"
      else
        self.query.conditions << "#{key} = '#{value}'"
      end
    end
  end
  self
end

#limit(limit) ⇒ YqlQuery::Builder

Assigns the limit for the query being constructed

Examples:

The limit may be passed as either a string or fixnum:

base = Builder.new.limit(5)
base = Builder.new.limit('5')

Parameters:

  • limit (Object) —

    The limit for the query.

Returns:



44
45
46
47
 
# File 'lib/yql_query/builder.rb', line 44

def limit(limit)
  self.query.limit = limit
  self
end

#offset(offset) ⇒ YqlQuery::Builder

Assigns the offset for the query being constructed

Examples:

The offset may be passed as either a string or fixnum:

base = Builder.new.offset(5)
base = Builder.new.offset('5')

Parameters:

  • offset (Object) —

    The offset for the query.

Returns:



57
58
59
60
 
# File 'lib/yql_query/builder.rb', line 57

def offset(offset)
  self.query.offset = offset
  self
end

#remote(remote_limit, remote_offset = 0) ⇒ YqlQuery::Builder

Assigns the remote limit for the query being constructed

Examples:

The remote limit may be passed as either a string or fixnum:

base = Builder.new.remote_limit(5)
base = Builder.new.remote_limit('5')

Parameters:

  • remote_limit (Object) —

    The remote limit for the query.

  • remote_offset (optional, Object) (defaults to: 0) —

    The remote offset for the query

Returns:

  • (YqlQuery::Builder) —

    YqlQuery::Builder instance reflecting the remote limit assigned.



71
72
73
74
75
 
# File 'lib/yql_query/builder.rb', line 71

def remote(remote_limit, remote_offset=0)
  self.query.remote_limit = remote_limit
  self.query.remote_offset = remote_offset
  self
end

#reset ⇒ Object

Resets all arguments to the query



256
257
258
 
# File 'lib/yql_query/builder.rb', line 256

def reset
  self.query = Query.new
end

#reverse ⇒ YqlQuery::Builder

Adds the reverse filter to the query being constructed

Examples:

base = Builder.new.reverse
base.to_s
# => "select * from tablename | reverse"

Returns:



212
213
214
215
 
# File 'lib/yql_query/builder.rb', line 212

def reverse
  self.query.reverse = true
  self
end

#sanitize(sanitize = true) ⇒ YqlQuery::Builder

Assigns the sanitize argument for the query being constructed

Examples:

Sanitize accepts either a string representing the column name or a boolean ‘true’ to sanitize all

base = Builder.new.sanitize('genre')
base.to_s
# => "select * from tablename | sanitize(field='genre')"

base = Builder.new.sanitize(true)
base.to_s
# => "select * from tablename | sanitize()"

Parameters:

  • sanitize (Object) (defaults to: true) —

    The sanitize argument for the query.

Returns:

  • (YqlQuery::Builder) —

    YqlQuery::Builder instance reflecting the sanitize filter assigned.



244
245
246
247
 
# File 'lib/yql_query/builder.rb', line 244

def sanitize(sanitize=true)
  self.query.sanitize = sanitize
  self
end

#select(select) ⇒ YqlQuery::Builder

Assigns the columns to select for the query being constructed

Examples:

The select may be passed as either a string or an array:

base = Builder.new.select('name')
base = Builder.new.select('name, age')
base = Builder.new.select(['name', 'age'])

Parameters:

  • select (Object) —

    The select arguments for the query.

Returns:

  • (YqlQuery::Builder) —

    YqlQuery::Builder instance reflecting the select arguments assigned.



86
87
88
89
 
# File 'lib/yql_query/builder.rb', line 86

def select(select)
  self.query.select = select
  self
end

#sort(sort) ⇒ YqlQuery::Builder

Assigns the field to be sorted for the query being constructed

Examples:

base = Builder.new.sort('name)

Parameters:

  • sort (Object) —

    The column to sort for the query.

Returns:



157
158
159
160
161
 
# File 'lib/yql_query/builder.rb', line 157

def sort(sort)
  self.query.sort = sort
  self.query.sort_descending = false
  self
end

#sort_descending(sort) ⇒ YqlQuery::Builder

Assigns the field to be sorted for the query being constructed

Examples:

base = Builder.new.sort('name)

Parameters:

  • sort (Object) —

    The column to sort descending for the query.

Returns:



170
171
172
173
174
 
# File 'lib/yql_query/builder.rb', line 170

def sort_descending(sort)
  self.query.sort = sort
  self.query.sort_descending = true
  self
end

#table(table) ⇒ YqlQuery::Builder

Assigns the table for the query being constructed

Parameters:

  • table (String) —

    The name of the table.

Returns:



31
32
33
34
 
# File 'lib/yql_query/builder.rb', line 31

def table(table)
  self.query.table = table
  self
end

#tail(tail) ⇒ YqlQuery::Builder

Assigns the tail argument for the query being constructed

Examples:

The tail argument may be passed as either a string or fixnum:

base = Builder.new.tail(5)
base = Builder.new.tail('5')

Parameters:

  • tail (Object) —

    The tail argument for the query.

Returns:

  • (YqlQuery::Builder) —

    YqlQuery::Builder instance reflecting the tail filter assigned.



184
185
186
187
 
# File 'lib/yql_query/builder.rb', line 184

def tail(tail)
  self.query.tail = tail
  self
end

#to_s ⇒ Object Also known as: to_query

Returns the generated YQL query based on the arguments provided



250
251
252
 
# File 'lib/yql_query/builder.rb', line 250

def to_s
  self.query.to_s
end

#truncate(truncate) ⇒ YqlQuery::Builder

Assigns the truncate argument for the query being constructed

Examples:

The truncate argument may be passed as either a string or fixnum:

base = Builder.new.truncate(5)
base = Builder.new.truncate('5')
base.to_s
# => "select * from tablename | truncate(5)"

Parameters:

  • truncate (Object) —

    The truncate argument for the query.

Returns:

  • (YqlQuery::Builder) —

    YqlQuery::Builder instance reflecting the truncate filter assigned.



199
200
201
202
 
# File 'lib/yql_query/builder.rb', line 199

def truncate(truncate)
  self.query.truncate = truncate
  self
end

#unique(unique) ⇒ YqlQuery::Builder

Assigns the unique argument for the query being constructed

Examples:

base = Builder.new.unique('genre')
base.to_s
# => "select * from tablename | unique(field='genre')"

Parameters:

  • truncate (Object) —

    The unique argument for the query.

Returns:

  • (YqlQuery::Builder) —

    YqlQuery::Builder instance reflecting the unique filter assigned.



226
227
228
229
 
# File 'lib/yql_query/builder.rb', line 226

def unique(unique)
  self.query.unique = unique
  self
end

#use(source, as) ⇒ YqlQuery::Builder

Assigns additional datatable sources for use with the query being constructed

Examples:

The select may be passed as either a string or an array:

base = Builder.new.use('http://anothersource/sometable.xml', 'sometable')
base.to_s
# => "use http://anothersource/sometable.xml as sometable; select * from tablename"

Parameters:

  • source (String) —

    The url of the data source.

  • as (String) —

    The name the data source will be referenced as in queries.

Returns:

  • (YqlQuery::Builder) —

    YqlQuery::Builder instance reflecting the data source arguments assigned.



101
102
103
104
 
# File 'lib/yql_query/builder.rb', line 101

def use(source, as)
  self.query.uses << Source.new(source, as)
  self
end