plume 0.1.0 → 0.2.0

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/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,17 @@
+# 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
+
+		def distinct = (@distinct == LiteralNil) ? distinct_kw? : @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

data/lib/plume/ast/generated_as_column_constraint.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Plume
+	class GeneratedAsColumnConstraint < ColumnConstraint
+		Type = _Union(:STORED, :VIRTUAL)
+
+		token :constraint_kw
+		token :name_tk
+		token :as_kw
+		token :as_lp
+		token :as_rp
+		token :type_tk
+
+		attribute :name, Stringy
+		attribute :type, Type
+		node :expression, Expression
+
+		def self.new(*, expression:, **) = super
+		def self.concrete(*, as_kw:, as_lp:, expression:, as_rp:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+		def type = (@type == LiteralNil) ? type_tk_val&.to_sym&.upcase : @type
+	end
+end

data/lib/plume/ast/indexed_column.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Plume
+	class IndexedColumn < Node
+		token :name_tk
+		token :collate_kw
+		token :collation_tk
+		token :direction_tk
+
+		attribute :name, Stringy
+		attribute :collation, Stringy
+		attribute :direction, Stringy
+
+		def self.new(*, name:, **) = super
+		def self.concrete(*, name_tk:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+		def collation = (@collation == LiteralNil) ? collation_tk_val&.to_sym&.upcase : @collation
+		def direction = (@direction == LiteralNil) ? direction_tk_val&.to_sym&.upcase : @direction
+	end
+end

data/lib/plume/ast/insert_statement.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_insert.html)**
+	#
+	# ```sql
+	# insert or ignore into t (a, b) select x, y from u on conflict (a) do nothing returning *
+	# ```
+	#
+	# Rows come from `select` (a SelectStatement, VALUES included) or are DEFAULT VALUES.
+	class InsertStatement < Node
+		include ConflictResolution
+
+		token :insert_kw # INSERT [OR …], or REPLACE
+		token :into_kw
+		token :columns_lp
+		token :columns_rp
+		token :default_values_kw
+
+		node :with_clause, WithClause
+		node :table, TableName
+		nodes :columns, ColumnName
+		node :select, SelectStatement
+		nodes :upserts, UpsertClause
+		node :returning, ReturningClause
+
+		def self.new(*, table:, **) = super
+		def self.concrete(*, insert_kw:, into_kw:, table:, **) = super
+
+		inspectable def or_action = TOKEN_TO_RESOLUTION[insert_kw_tok]
+		inspectable def default_values = default_values_kw?
+
+		def column_names = columns&.map(&:column)
+	end
+end

data/lib/plume/ast/join.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Plume
+	class Join < Node
+		node :operator, JoinOperator
+		node :source, _Any
+		node :constraint, _Union(JoinOnConstraint, JoinUsingConstraint)
+
+		def self.new(*, operator:, source:, **) = super
+		def self.concrete(*, operator:, source:, **) = super
+	end
+end

data/lib/plume/ast/join_clause.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plume
+	# `left` followed by one or more joins. Comma-separated sources are joins too,
+	# with a `:COMMA` operator
+	class JoinClause < Node
+		node :left, _Any
+		nodes :joins, Join
+
+		def self.new(*, left:, joins:, **) = super
+		def self.concrete(*, left:, joins:, **) = super
+
+		def sources = [left, *joins.map(&:source)]
+	end
+end

data/lib/plume/ast/join_on_constraint.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Plume
+	class JoinOnConstraint < Node
+		token :on_kw
+
+		node :expression, Expression
+
+		def self.new(*, expression:, **) = super
+		def self.concrete(*, on_kw:, expression:, **) = super
+	end
+end

data/lib/plume/ast/join_operator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Plume
+	class JoinOperator < Node
+		Kind = _Union(:COMMA, :INNER, :LEFT, :RIGHT, :FULL, :CROSS)
+
+		token :operator_tk
+
+		attribute :kind, Kind
+		attribute :natural, _Boolean
+
+		def self.new(*, kind:, **) = super
+		def self.concrete(*, operator_tk:, **) = super
+
+		def kind
+			return @kind unless @kind == LiteralNil
+
+			keywords = operator_keywords
+			return :COMMA if keywords == [:COMMA]
+
+			(keywords & [:LEFT, :RIGHT, :FULL, :CROSS]).first || :INNER
+		end
+
+		def natural = (@natural == LiteralNil) ? operator_keywords.include?(:NATURAL) : @natural
+		def outer? = [:LEFT, :RIGHT, :FULL].include?(kind)
+
+		private
+
+		def operator_keywords = Array(operator_tk_tok)
+	end
+end

data/lib/plume/ast/join_using_constraint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Plume
+	class JoinUsingConstraint < Node
+		token :using_kw
+		token :columns_lp
+		token :columns_rp
+
+		nodes :columns, ColumnName
+
+		def self.new(*, columns:, **) = super
+		def self.concrete(*, using_kw:, columns:, **) = super
+
+		def column_names = columns.map(&:column)
+	end
+end

data/lib/plume/ast/like_expression.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Plume
+	# `left [NOT] LIKE right [ESCAPE escape]`. GLOB, REGEXP and MATCH have no ESCAPE
+	# and are plain `BinaryExpression`s
+	class LikeExpression < Node
+		token :operator_tk
+		token :escape_kw
+
+		node :left, Expression
+		node :right, Expression
+		node :escape, Expression
+
+		def self.new(*, left:, right:, **) = super
+		def self.concrete(*, operator_tk:, left:, right:, **) = super
+
+		def operator = :LIKE
+	end
+end