Module: Card::Query

Defined in:

lib/card/query.rb,
lib/card/query/join.rb,
lib/card/query/value.rb,
lib/card/query/clause.rb,
lib/card/query/act_query.rb,
lib/card/query/card_query.rb,
lib/card/query/action_query.rb,
lib/card/query/sql_statement.rb,
lib/card/query/abstract_query.rb,
lib/card/query/card_query/run.rb,
lib/card/query/reference_query.rb,
lib/card/query/abstract_query/tie.rb,
lib/card/query/card_query/sorting.rb,
lib/card/query/card_query/found_by.rb,
lib/card/query/sql_statement/joins.rb,
lib/card/query/sql_statement/order.rb,
lib/card/query/sql_statement/where.rb,
lib/card/query/card_query/conjunctions.rb,
lib/card/query/card_query/normalization.rb,
lib/card/query/card_query/interpretation.rb,
lib/card/query/abstract_query/query_helper.rb,
lib/card/query/card_query/match_attributes.rb,
lib/card/query/card_query/reference_attributes.rb,
lib/card/query/card_query/relational_attributes.rb

Overview

Card::Query is for finding implicit lists (or counts of lists) of cards.

Search and Set cards use Card::Query to query the database, and it's also frequently used directly in code.

Query "statements" (objects, really) are made in WQL (Wagn Query Language). Because WQL is used by Deckers, the primary language documentation is on wagn.org. (https://decko.org/WQL_Syntax). Note that the examples there are in JSON, like Search card content, but statements in Card::Query are in ruby form.

In Decko's current form, Card::Query generates and executes SQL statements. However, the SQL generation is largely (not yet fully) separated from the WQL statement interpretation.

The most common way to use Card::Query is as follows: list_of_cards = Card::Query.run(statement)

This is equivalent to: query = Card::Query.new(statement) list_of_cards = query.run

Upon initiation, the query is interpreted, and the following key objects are populated:

• @join - an Array of Card::Query::Join objects
• @conditions - an Array of conditions
• @mod - a Hash of other query-altering keys
• @subqueries - a list of other queries nested within this one

Each condition is either a SQL-ready string (boo) or an Array in this form: [ field_string_or_sym, Card::Value::Query object ]

Defined Under Namespace

Modules: Clause Classes: AbstractQuery, ActQuery, ActionQuery, CardQuery, Join, ReferenceQuery, SqlStatement, Value

Constant Summary

ATTRIBUTES =

Card::Query::CardQuery After conversion, ATTRIBUTES is a Hash where the key is the attribute and the value is the attribute type: { id: :basic, name: :basic, key: :basic ...} This is used for rapid attribute type lookups in the interpretation phase.

{
  # Each of the "basic" fields corresponds directly to a database field.
  # their values are translated fairly directly into SQL-safe values.
  # (These are referred to as "properties" in WQL documentation. Need to
  # reconcile #EFM)
  basic:           %i[id name key type_id content left_id right_id
                      creator_id updater_id codename read_rule_id],
  # "Relational" values can involve tying multiple queries together
  relational:      %i[type
                      part left right
                      editor_of edited_by last_editor_of last_edited_by
                      creator_of created_by
                      updater_of updated_by
                      link_to linked_to_by
                      include included_by
                      nest nested_by

                      refer_to referred_to_by
                      member_of member

                      found_by
                      not sort match name_match complete],

  plus_relational: %i[plus left_plus right_plus],
  conjunction:     %i[and or all any],
  ignore:          %i[prepend append view params vars size]
}.each_with_object({}) do |pair, h|
  pair[1].each { |v| h[v] = pair[0] }
end

CONJUNCTIONS =

{ any: :or, in: :or, or: :or, all: :and, and: :and }.freeze

MODIFIERS =

%i[conj return sort sort_as group dir limit offset]
.each_with_object({}) { |v, h| h[v] = nil }

OPERATORS =

%w[!= = =~ < > in ~].each_with_object({}) { |v, h| h[v] = v }.merge(
  {
    eq: "=", gt: ">", lt: "<", match: "~", ne: "!=", "not in": "not in"
  }.stringify_keys
)

DEFAULT_ORDER_DIRS =

{ update: "desc", relevance: "desc" }.freeze

Class Method Summary

• .class_for(type) ⇒ Object
• .new(statement, comment = nil) ⇒ Object
• .run(statement, comment = nil) ⇒ Object
• .safe_sql(txt) ⇒ Object

Class Method Details

.class_for(type) ⇒ Object

# File 'lib/card/query.rb', line 98

def class_for type
  const_get "#{type.capitalize}Query"
end

.new(statement, comment = nil) ⇒ Object

# File 'lib/card/query.rb', line 90

def new statement, comment=nil
  Query::CardQuery.new statement, comment
end

.run(statement, comment = nil) ⇒ Object

# File 'lib/card/query.rb', line 94

def run statement, comment=nil
  new(statement, comment).run
end

.safe_sql(txt) ⇒ Object

# File 'lib/card/query.rb', line 102

def safe_sql txt
  txt = txt.to_s
  raise "WQL contains disallowed characters: #{txt}" if txt.match?(/[^\w\s*().,]/)

  txt
end