plume 0.1.0 → 0.3.0

data/lib/plume/ast/compound_select.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Plume
+	# Compound operators all have the same precedence and associate to the left, so
+	# `a UNION b EXCEPT c` is `(a UNION b) EXCEPT c` and `right` is never a compound
+	class CompoundSelect < Node
+		TOKEN_TO_OPERATOR = {
+			:UNION                    => :UNION,
+			[:UNION, :ALL].freeze     => :UNION_ALL,
+			:INTERSECT                => :INTERSECT,
+			:EXCEPT                   => :EXCEPT,
+		}.freeze
+		Operator = _Union(*TOKEN_TO_OPERATOR.values)
+
+		token :operator_tk
+
+		attribute :operator, Operator
+		node :left, _Any
+		node :right, _Any
+
+		def self.new(*, operator:, left:, right:, **) = super
+		def self.concrete(*, operator_tk:, left:, right:, **) = super
+
+		def operator = (@operator == LiteralNil) ? TOKEN_TO_OPERATOR[operator_tk_tok] : @operator
+
+		def cores
+			[*((CompoundSelect === left) ? left.cores : [left]), right]
+		end
+	end
+end

data/lib/plume/ast/conflict_clause.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Plume
+	class ConflictClause < Node
+		RAISE_KWS = Set[:ROLLBACK, :ABORT, :FAIL].freeze
+		RESOLVE_KWS = Set[:IGNORE, :REPLACE].freeze
+		RESOLUTIONS = (RAISE_KWS + RESOLVE_KWS).freeze
+
+		token :on_conflict_kw
+		token :resolution_kw
+
+		attribute :resolution, RESOLUTIONS
+
+		def self.new(*, resolution:, **) = super
+		def self.concrete(*, on_conflict_kw:, resolution_kw:, **) = super
+
+		def resolution = (@resolution == LiteralNil) ? resolution_kw_src.to_sym.upcase : @resolution
+
+		def raise? = RAISE_KWS.include?(resolution)
+		def resolve? = RESOLVE_KWS.include?(resolution)
+	end
+end

data/lib/plume/ast/conflict_resolution.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Plume
+	# Shared by INSERT and UPDATE: the `OR …` part of `INSERT OR REPLACE`, and REPLACE on its own
+	module ConflictResolution
+		TOKEN_TO_RESOLUTION = {
+			[:INSERT, :OR, :ROLLBACK].freeze => :ROLLBACK,
+			[:INSERT, :OR, :ABORT].freeze    => :ABORT,
+			[:INSERT, :OR, :FAIL].freeze     => :FAIL,
+			[:INSERT, :OR, :IGNORE].freeze   => :IGNORE,
+			[:INSERT, :OR, :REPLACE].freeze  => :REPLACE,
+			[:UPDATE, :OR, :ROLLBACK].freeze => :ROLLBACK,
+			[:UPDATE, :OR, :ABORT].freeze    => :ABORT,
+			[:UPDATE, :OR, :FAIL].freeze     => :FAIL,
+			[:UPDATE, :OR, :IGNORE].freeze   => :IGNORE,
+			[:UPDATE, :OR, :REPLACE].freeze  => :REPLACE,
+			:REPLACE                         => :REPLACE,
+		}.freeze
+	end
+end

data/lib/plume/ast/create_index_statement.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_createindex.html)**
+	class CreateIndexStatement < Node
+		token :create_kw
+		token :unique_kw
+		token :index_kw
+		token :if_not_exists_kw
+		token :on_kw
+		token :table_tk
+		token :columns_lp
+		token :columns_rp
+		token :where_kw
+
+		node :index, TableName
+		attribute :table, Stringy
+		nodes :columns, OrderingTerm
+		node :condition, Expression
+
+		def self.new(*, index:, table:, columns:, **) = super
+		def self.concrete(*, create_kw:, index_kw:, index:, table_tk:, columns:, **) = super
+
+		def table = (@table == LiteralNil) ? table_tk_val : @table
+
+		inspectable def unique = unique_kw?
+		inspectable def if_not_exists = if_not_exists_kw?
+	end
+end

data/lib/plume/ast/create_table_statement.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Plume
+	# - `schema_name` → `_Nilable(String)`
+	# - `table_name` → `String`
+	# - `select_statement` → `_Nilable(SelectStatement)`
+	# - `columns` → `_Array(ColumnDefinition)`
+	# - `strict` → `_Nilable(_Boolean)`
+	# - `temporary` → `_Nilable(_Boolean)`
+	# - `if_not_exists` → `_Nilable(_Boolean)`
+	# - `without_row_id` → `_Nilable(_Boolean)`
+	# - `constraints` → `_Array(TableConstraint)`
+	#
+	# **[SQLite Docs](https://www.sqlite.org/lang_createtable.html)**
+	#
+	# ```sql
+	# create table tb0 (c0 primary key desc on conflict abort autoincrement)
+	# ```
+	class CreateTableStatement < Node
+		token :create_kw
+		token :temp_kw
+		token :table_kw
+		token :if_not_exists_kw
+		token :columns_lp
+		token :columns_rp
+		token :as_kw
+
+		attribute :temporary, _Boolean
+		attribute :if_not_exists, _Boolean
+		node  :table,           TableName
+		nodes :columns,         ColumnDefinition
+		nodes :constraints,     TableConstraint
+		nodes :options,         TableOption
+
+		node :select_statement, _Any
+
+		def self.new(*, table:, **) = super
+		def self.concrete(*, create_kw:, table_kw:, **) = super
+
+		def table = (@table == LiteralNil) ? table_tk_val : @table
+		def temporary = (@temporary == LiteralNil) ? temp_kw? : @temporary
+		def if_not_exists = (@if_not_exists == LiteralNil) ? if_not_exists_kw? : @if_not_exists
+
+		inspectable def strict         = (@options != LiteralNil) ? @options&.any?(StrictTableOption) : false
+		inspectable def without_row_id = (@options != LiteralNil) ? @options&.any?(WithoutRowidTableOption) : false
+	end
+end

data/lib/plume/ast/create_trigger_statement.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_createtrigger.html)**
+	class CreateTriggerStatement < Node
+		token :create_kw
+		token :temp_kw
+		token :trigger_kw
+		token :if_not_exists_kw
+		token :time_kw # BEFORE, AFTER or INSTEAD OF
+		token :event_kw # DELETE, INSERT, UPDATE or UPDATE OF
+		token :on_kw
+		token :for_each_row_kw
+		token :when_kw
+		token :begin_kw
+		token :end_kw
+
+		node :trigger, TableName
+		nodes :columns, ColumnName
+		node :table, TableName
+		node :condition, Expression
+		nodes :statements, _Any
+
+		def self.new(*, trigger:, table:, statements:, **) = super
+		def self.concrete(*, create_kw:, trigger_kw:, trigger:, table:, statements:, **) = super
+
+		inspectable def temporary = temp_kw?
+		inspectable def if_not_exists = if_not_exists_kw?
+
+		# :BEFORE, :AFTER, :INSTEAD_OF, or nil (which SQLite treats as BEFORE)
+		inspectable def time
+			case time_kw_tok
+			when :BEFORE then :BEFORE
+			when :AFTER then :AFTER
+			when [:INSTEAD, :OF] then :INSTEAD_OF
+			end
+		end
+
+		# :DELETE, :INSERT or :UPDATE
+		inspectable def event = Array(event_kw_tok).first
+		def column_names = columns&.map(&:column)
+	end
+end

data/lib/plume/ast/create_view_statement.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_createview.html)**
+	#
+	# ```sql
+	# create temp view if not exists v (a, b) as select 1, 2
+	# ```
+	class CreateViewStatement < Node
+		token :create_kw
+		token :temp_kw
+		token :view_kw
+		token :if_not_exists_kw
+		token :columns_lp
+		token :columns_rp
+		token :as_kw
+
+		node :view, TableName
+		nodes :columns, IndexedColumn
+		node :select, SelectStatement
+
+		def self.new(*, view:, select:, **) = super
+		def self.concrete(*, create_kw:, view_kw:, view:, select:, **) = super
+
+		inspectable def temporary = temp_kw?
+		inspectable def if_not_exists = if_not_exists_kw?
+
+		def column_names = columns&.map(&:name)
+	end
+end

data/lib/plume/ast/create_virtual_table_statement.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_createvtab.html)**
+	#
+	# Module arguments are free-form - every module has its own syntax for them - so they
+	# are kept as the source text between the commas
+	class CreateVirtualTableStatement < Node
+		token :create_virtual_table_kw
+		token :if_not_exists_kw
+		token :using_kw
+		token :module_tk
+		token :arguments_lp
+		token :arguments_rp
+
+		node :table, TableName
+		attribute :module_name, Stringy
+		attribute :arguments, _Array(String)
+
+		def self.new(*, table:, module_name:, **) = super
+		def self.concrete(*, create_virtual_table_kw:, table:, module_tk:, **) = super
+
+		def module_name = (@module_name == LiteralNil) ? module_tk_val : @module_name
+		def arguments = (@arguments.nil? || LiteralNil.equal?(@arguments)) ? [] : @arguments
+
+		inspectable def if_not_exists = if_not_exists_kw?
+	end
+end

data/lib/plume/ast/default_column_constraint.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Plume
+	class DefaultColumnConstraint < ColumnConstraint
+		token :constraint_kw
+		token :name_tk
+		token :default_kw
+		token :default_lp
+		token :default_rp
+		token :value_tk
+
+		attribute :name, Stringy
+		attribute :value, Expression
+
+		def self.new(*, **) = super
+		def self.concrete(*, default_kw:, **) = super
+
+		# Parser may pass either tokens or attributes, so
+		# require none in `concrete` signature but ensure presence here.
+		def after_initialize
+			if @value.nil? && @value_tk.nil?
+				raise ArgumentError.new("missing either: :value, :value_tk")
+			end
+		end
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+		def value = (@value == LiteralNil) ? value_tk_val : @value
+	end
+end

data/lib/plume/ast/deferrable_column_constraint.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Plume
+	# `[NOT] DEFERRABLE [INITIALLY DEFERRED | INITIALLY IMMEDIATE]` on its own among a column's
+	# constraints, where SQLite's grammar allows it (`ccons ::= defer_subclause`)
+	class DeferrableColumnConstraint < ColumnConstraint
+		token :constraint_kw
+		token :name_tk
+		token :deferrable_span
+
+		attribute :name, Stringy
+		attribute :deferred, ForeignKeyClause::Deferrable
+
+		def self.new(*, **) = super
+		def self.concrete(*, deferrable_span:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+		def deferred = (@deferred == LiteralNil) ? ForeignKeyClause::TOKEN_TO_DEFERRABLE[deferrable_span_tok] : @deferred
+	end
+end

data/lib/plume/ast/delete_statement.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_delete.html)**
+	#
+	# ```sql
+	# delete from t where a > 1 returning *
+	# ```
+	class DeleteStatement < Node
+		token :delete_kw
+		token :from_kw
+		token :where_kw
+		token :order_by_kw
+		token :limit_kw
+		token :offset_tk
+
+		node :with_clause, WithClause
+		node :table, TableName
+		node :condition, Expression
+		node :returning, ReturningClause
+		nodes :orderings, OrderingTerm
+		node :limit, Expression
+		node :offset, Expression
+
+		def self.new(*, table:, **) = super
+		def self.concrete(*, delete_kw:, from_kw:, table:, **) = super
+	end
+end

data/lib/plume/ast/detach_statement.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_detach.html)**
+	class DetachStatement < Node
+		token :detach_kw # DETACH or DETACH DATABASE
+
+		node :schema, Expression
+
+		def self.new(*, schema:, **) = super
+		def self.concrete(*, detach_kw:, schema:, **) = super
+	end
+end

data/lib/plume/ast/drop_statement.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Plume
+	# DROP TABLE, DROP INDEX, DROP VIEW and DROP TRIGGER, told apart by `type`
+	#
+	# **[SQLite Docs](https://www.sqlite.org/lang_droptable.html)**
+	class DropStatement < Node
+		token :drop_kw
+		token :type_kw
+		token :if_exists_kw
+
+		node :target, TableName
+
+		def self.new(*, target:, **) = super
+		def self.concrete(*, drop_kw:, type_kw:, target:, **) = super
+
+		# :TABLE, :INDEX, :VIEW or :TRIGGER
+		inspectable def type = type_kw_tok
+		inspectable def if_exists = if_exists_kw?
+	end
+end

data/lib/plume/ast/empty_function_argument.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Plume
+	class EmptyFunctionArgument < Node
+	end
+end

data/lib/plume/ast/exists_expression.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plume
+	# `EXISTS (SELECT …)`. `NOT EXISTS` is a `UnaryExpression` wrapping this
+	class ExistsExpression < Node
+		token :exists_kw
+		token :select_lp
+		token :select_rp
+
+		node :select, SelectStatement
+
+		def self.new(*, select:, **) = super
+		def self.concrete(*, select:, **) = super
+	end
+end

data/lib/plume/ast/explain_statement.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_explain.html)**
+	class ExplainStatement < Node
+		token :explain_kw # EXPLAIN or EXPLAIN QUERY PLAN
+
+		node :statement, _Any
+
+		def self.new(*, statement:, **) = super
+		def self.concrete(*, explain_kw:, statement:, **) = super
+
+		inspectable def query_plan = explain_kw_tok == [:EXPLAIN, :QUERY, :PLAN]
+	end
+end

data/lib/plume/ast/expression.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Plume
+	# No plain values (nil, true, symbols) in here, see Node.attribute for why
+	Expression = _Union(
+		Numeric,
+		String,
+		Token,
+		ColumnName,
+		TableName,
+		_Deferred {
+			_Union(
+				UnaryExpression,
+				BinaryExpression,
+				CastExpression,
+				TernaryExpression,
+				LikeExpression,
+				CaseExpression,
+				CollationExpression,
+				RaiseExpression,
+				FunctionReference,
+				LiteralExpression,
+				ParentheticalExpression,
+				SubqueryExpression,
+				ExistsExpression,
+				Variable,
+			)
+		},
+	)
+end

data/lib/plume/ast/foreign_key_action.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Plume
+	class ForeignKeyAction < Node
+		TOKEN_TO_ACTION = {
+			:CASCADE                => :CASCADE,
+			:RESTRICT               => :RESTRICT,
+			[:SET, :NULL].freeze    => :SET_NULL,
+			[:SET, :DEFAULT].freeze => :SET_DEFAULT,
+			[:NO, :ACTION].freeze   => :NO_ACTION,
+		}.freeze
+
+		token :on_kw
+		token :trigger_kw
+		token :action_kw
+
+		attribute :trigger, Stringy
+		attribute :action, _Union(*TOKEN_TO_ACTION.values)
+
+		def self.new(*, trigger:, action:, **) = super
+		def self.concrete(*, on_kw:, trigger_kw:, action_kw:, **) = super
+
+		def trigger = (@trigger == LiteralNil) ? trigger_kw_src.to_sym.upcase : @trigger
+		def action = (@action == LiteralNil) ? TOKEN_TO_ACTION[action_kw_tok] : @action
+	end
+end

data/lib/plume/ast/foreign_key_clause.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Plume
+	class ForeignKeyClause < Node
+		TOKEN_TO_DEFERRABLE = {
+			:DEFERRABLE                                        => false,
+			[:DEFERRABLE].freeze                               => false,
+			[:NOT, :DEFERRABLE].freeze                         => false,
+			[:DEFERRABLE, :INITIALLY, :DEFERRED].freeze        => true,
+			[:DEFERRABLE, :INITIALLY, :IMMEDIATE].freeze       => false,
+			[:NOT, :DEFERRABLE, :INITIALLY, :DEFERRED].freeze  => false,
+			[:NOT, :DEFERRABLE, :INITIALLY, :IMMEDIATE].freeze => false,
+		}.freeze
+		Deferrable = _Union(*TOKEN_TO_DEFERRABLE.values.uniq)
+
+		token :references_kw
+		token :table_tk
+		token :columns_lp
+		token :columns_rp
+		token :deferrable_span
+
+		attribute :table, Stringy
+		attribute :deferred, Deferrable
+		nodes :columns, IndexedColumn
+		nodes :actions, ForeignKeyAction
+		nodes :match_clauses, MatchClause
+
+		def self.new(*, table:, **) = super
+		def self.concrete(*, references_kw:, table_tk:, **) = super
+
+		def table = (@table == LiteralNil) ? table_tk_val : @table
+		def deferred = (@deferred == LiteralNil) ? TOKEN_TO_DEFERRABLE[deferrable_span_tok] : @deferred
+
+		def on_delete
+			actions.reverse_each do |it|
+				return it.action if it.trigger == :DELETE
+			end
+		end
+
+		def on_update
+			actions.reverse_each do |it|
+				return it.action if it.trigger == :UPDATE
+			end
+		end
+
+		def match_type
+			match_clauses.last.type
+		end
+	end
+end

data/lib/plume/ast/foreign_key_column_constraint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Plume
+	class ForeignKeyColumnConstraint < ColumnConstraint
+		token :constraint_kw
+		token :name_tk
+
+		attribute :name, Stringy
+		node :foreign_key_clause, ForeignKeyClause
+
+		def self.new(*, foreign_key_clause:, **) = super
+		def self.concrete(*, foreign_key_clause:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+	end
+end

data/lib/plume/ast/foreign_key_table_constraint.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Plume
+	class ForeignKeyTableConstraint < TableConstraint
+		token :constraint_kw
+		token :name_tk
+		token :foreign_key_kw
+		token :foreign_key_lp
+		token :foreign_key_rp
+
+		attribute :name, Stringy
+		nodes :columns, IndexedColumn
+		node :foreign_key_clause, ForeignKeyClause
+
+		def self.new(*, columns:, foreign_key_clause:, **) = super
+		def self.concrete(*, foreign_key_kw:, columns:, foreign_key_clause:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+	end
+end

data/lib/plume/ast/frame_boundary.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Plume
+	class FrameBoundary < Node
+		Type = _Union(
+			:PRECEDING, "PRECEDING", :preceding, "preceding",
+			:FOLLOWING, "FOLLOWING", :following, "following",
+			:CURRENT_ROW, "CURRENT_ROW", :current_row, "current_row",
+		)
+		Value = _Union(
+			:UNBOUNDED, "UNBOUNDED", :unbounded, "unbounded",
+			Expression,
+		)
+
+		token :type_tk
+		token :value_tk
+
+		attribute :type, Type
+		attribute :value, Value
+
+		def self.new(*, type:, **) = super
+		def self.concrete(*, type_tk:, **) = super
+
+		# Parser may pass either tokens or attributes, so
+		# require none in `concrete` signature but ensure presence here.
+		def after_initialize
+			if @value.nil? && @value_tk.nil?
+				raise ArgumentError.new("missing either: :value, :value_tk")
+			end
+		end
+
+		def type = (@type == LiteralNil) ? type_tk_src.gsub(" ", "_").to_sym.upcase : @type
+		def value = (@value == LiteralNil) ? value_tk_src&.to_sym&.upcase : @value
+	end
+end

data/lib/plume/ast/frame_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Plume
+	class FrameSpec < Node
+		Type = _Union(
+			:RANGE, "RANGE", :range, "range",
+			:ROWS, "ROWS", :rows, "rows",
+			:GROUPS, "GROUPS", :groups, "groups",
+		)
+		Exclude = _Union(
+			:NO_OTHERS, "NO_OTHERS", :no_others, "no_others",
+			:CURRENT_ROW, "CURRENT_ROW", :current_row, "current_row",
+			:GROUP, "GROUP", :group, "group",
+			:TIES, "TIES", :ties, "ties",
+		)
+
+		token :type_tk
+		token :between_kw
+		token :and_kw
+		token :exclude_kw
+		token :exclude_tk
+
+		attribute :type, Type
+		attribute :exclude, Exclude
+		node :starting_boundary, FrameBoundary
+		node :ending_boundary, FrameBoundary
+
+		def self.new(*, type:, starting_boundary:, **) = super
+		def self.concrete(*, type_tk:, starting_boundary:, **) = super
+
+		def type = (@type == LiteralNil) ? type_tk_src.to_sym.upcase : @type
+		def exclude = (@exclude == LiteralNil) ? exclude_tk_src&.gsub(" ", "_")&.to_sym&.upcase : @exclude
+	end
+end

data/lib/plume/ast/function_arguments.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Plume
+	class FunctionArguments < Node
+		token :distinct_kw
+		token :order_by_kw
+
+		attribute :distinct, _Boolean
+		nodes :expressions, Expression
+		nodes :order_by, OrderingTerm
+
+		def self.new(*, expressions:, **) = super
+		def self.concrete(*, expressions:, **) = super
+
+		# ALL is the default, written out - only DISTINCT makes the aggregate distinct
+		def distinct = (@distinct == LiteralNil) ? (distinct_kw_tok == :DISTINCT) : @distinct
+	end
+end

data/lib/plume/ast/function_reference.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Plume
+	class FunctionReference < Node
+		token :schema_tk
+		token :dot_tk
+		token :function_tk
+		token :arguments_lp
+		token :arguments_rp
+		token :within_group_kw
+		token :within_lp
+		token :within_rp
+
+		attribute :schema, Stringy
+		attribute :function, Stringy
+		node :arguments, _Union(FunctionArguments, StarFunctionArgument, EmptyFunctionArgument)
+		node :within_group, Expression # the ORDER BY expression of an ordered-set aggregate
+		node :filter_clause, Expression
+		node :over_clause, OverClause
+
+		def self.new(*, function:, **) = super
+		def self.concrete(*, function_tk:, **) = super
+
+		def schema = (@schema == LiteralNil) ? schema_tk_val : @schema
+		def function = (@function == LiteralNil) ? function_tk_val : @function
+
+		alias_method :name, :function
+	end
+end