plume 0.1.0 → 0.3.0

data/lib/plume/ast/ordering_term.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Plume
+	class OrderingTerm < Node
+		Direction = _Union(
+			:ASC, "ASC", :asc, "asc", :ASCENDING, "ASCENDING", :ascending, "ascending",
+			:DESC, "DESC", :desc, "desc", :DESCENDING, "DESCENDING", :descending, "descending",
+		)
+		Nulls = _Union(
+			:FIRST, "FIRST", :first, "first",
+			:LAST, "LAST", :last, "last",
+		)
+
+		token :collate_kw
+		token :collation_tk
+		token :direction_tk
+		token :nulls_kw
+		token :nulls_tk
+
+		node :expression, Expression
+		attribute :collation, Stringy
+		attribute :direction, Direction
+		attribute :nulls, Nulls
+
+		def self.new(*, **) = super
+		def self.concrete(*, **) = super
+
+		def collation = (@collation == LiteralNil) ? Node.collation_name(collation_tk_val) : @collation
+		def direction = (@direction == LiteralNil) ? direction_tk_val&.to_sym&.upcase : @direction
+		def nulls = (@nulls == LiteralNil) ? nulls_tk_val&.to_sym&.upcase : @nulls
+	end
+end

data/lib/plume/ast/over_clause.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Plume
+	class OverClause < Node
+		token :over_kw
+		token :window_lp
+		token :base_window_name_tk
+		token :partition_by_kw
+		token :order_by_kw
+		token :window_rp
+		token :window_name_tk
+
+		nodes :partitions, Expression
+		nodes :orderings, OrderingTerm
+		node :frame, FrameSpec
+		attribute :window_name, Stringy
+		attribute :base_window_name, Stringy
+
+		def self.new(*, **) = super
+		def self.concrete(*, over_kw:, **) = super
+
+		def window_name = (@window_name == LiteralNil) ? window_name_tk_val : @window_name
+		def base_window_name = (@base_window_name == LiteralNil) ? base_window_name_tk_val : @base_window_name
+	end
+end

data/lib/plume/ast/parenthetical_expression.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Plume
+	class ParentheticalExpression < Node
+		token :value_lp
+		token :value_tk
+		token :value_rp
+
+		# Hand-built trees may wrap plain Ruby values; a lambda keeps them out of the union's
+		# plain-value set, see Node.attribute
+		attribute :value, _Union(Expression, _Array(Expression), -> (v) { LiteralValue === v })
+
+		def self.new(*, value:, **) = super
+		def self.concrete(*, **) = super
+
+		# Parser may pass either tokens or attributes, so
+		# require none in `concrete` signature but ensure presence here.
+		def after_initialize
+			if @value == LiteralNil && @value_tk == LiteralNil
+				raise ArgumentError.new("missing either: :value, :value_tk")
+			end
+		end
+
+		# The child as stored - nil only for the empty list of `x IN ()`. Unlike `value`, a NULL
+		# literal stays a node, so it cannot be mistaken for that empty list
+		def contents = LiteralNil.equal?(@value) ? value_tk_val : @value
+
+		def value
+			case (v = contents)
+			when LiteralNil then nil
+			when LiteralFalse then false
+			when LiteralExpression then v.value
+			else v
+			end
+		end
+	end
+end

data/lib/plume/ast/parenthetical_source.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Plume
+	# A parenthesized join or source list used as a FROM source, like `(a JOIN b) AS ab`
+	class ParentheticalSource < Node
+		token :source_lp
+		token :source_rp
+		token :as_kw
+		token :alias_tk
+
+		node :source, _Any
+		attribute :alias, Stringy
+
+		def self.new(*, source:, **) = super
+		def self.concrete(*, source:, **) = super
+
+		def alias = (@alias == LiteralNil) ? alias_tk_val : @alias
+	end
+end

data/lib/plume/ast/pragma_statement.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/pragma.html)**
+	class PragmaStatement < Node
+		token :pragma_kw
+		token :schema_tk
+		token :dot_tk
+		token :name_tk
+		token :eq_tk # `=`, or the opening parenthesis of `PRAGMA name(value)`
+		token :value_tk
+		token :value_rp
+
+		attribute :schema, Stringy
+		attribute :name, Stringy
+
+		def self.new(*, name:, **) = super
+		def self.concrete(*, pragma_kw:, name_tk:, **) = super
+
+		def schema = (@schema == LiteralNil) ? schema_tk_val : @schema
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+
+		# As written: numbers come out as numbers, keywords and names as strings
+		inspectable def value = value_tk_val
+	end
+end

data/lib/plume/ast/primary_key_column_constraint.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Plume
+	class PrimaryKeyColumnConstraint < ColumnConstraint
+		token :constraint_kw
+		token :name_tk
+		token :primary_key_kw
+		token :direction_tk
+		token :autoincrement_kw
+
+		attribute :name, Stringy
+		attribute :direction, Stringy
+		attribute :autoincrement, _Boolean
+		node :conflict_clause, ConflictClause
+
+		def self.new(*, **) = super
+		def self.concrete(*, primary_key_kw:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+		def direction = (@direction == LiteralNil) ? direction_tk_val&.to_sym&.upcase : @direction
+		def autoincrement = (@autoincrement == LiteralNil) ? autoincrement_kw? : @autoincrement
+	end
+end

data/lib/plume/ast/primary_key_table_constraint.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Plume
+	class PrimaryKeyTableConstraint < TableConstraint
+		token :constraint_kw
+		token :name_tk
+		token :primary_key_kw
+		token :primary_key_lp
+		token :autoincrement_kw
+		token :primary_key_rp
+
+		attribute :name, Stringy
+		attribute :autoincrement, _Boolean
+		nodes :columns, IndexedColumn
+		node :conflict_clause, ConflictClause
+
+		def self.new(*, columns:, **) = super
+		def self.concrete(*, primary_key_kw:, columns:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+		def autoincrement = (@autoincrement == LiteralNil) ? autoincrement_kw? : @autoincrement
+	end
+end

data/lib/plume/ast/raise_expression.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Plume
+	class RaiseExpression < Node
+		Type = _Union(:IGNORE, :ROLLBACK, :ABORT, :FAIL)
+
+		token :raise_kw              # required
+		token :raise_lp              # required
+		token :type_kw               # required
+		token :comma                 # maybe
+		token :error_message_tk      # maybe
+		token :raise_rp              # required
+
+		attribute :type,          Type    # required
+		attribute :error_message, Expression # maybe
+
+		def self.new(*, type:, **) = super
+		def self.concrete(*, raise_kw:, raise_lp:, type_kw:, raise_rp:, **) = super
+
+		def type = (@type == LiteralNil) ? type_kw_src.to_sym.upcase : @type
+		def error_message = (@error_message == LiteralNil) ? error_message_tk_val : @error_message
+	end
+end

data/lib/plume/ast/reindex_statement.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_reindex.html)**
+	#
+	# `target` names a schema, table or index - SQLite works out which at run time
+	class ReindexStatement < Node
+		token :reindex_kw
+
+		node :target, TableName
+
+		def self.new(*, **) = super
+		def self.concrete(*, reindex_kw:, **) = super
+	end
+end

data/lib/plume/ast/release_statement.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_savepoint.html)**
+	class ReleaseStatement < Node
+		token :release_kw # RELEASE or RELEASE SAVEPOINT
+		token :name_tk
+
+		attribute :name, Stringy
+
+		def self.new(*, name:, **) = super
+		def self.concrete(*, release_kw:, name_tk:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+	end
+end

data/lib/plume/ast/result_column.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Plume
+	class ResultColumn < Node
+		token :as_kw
+		token :alias_tk
+		token :result_tk
+
+		node :result, Expression
+		attribute :alias, Stringy
+
+		def self.new(*, result:, **) = super
+		def self.concrete(*, **) = super
+
+		def result = (@result == LiteralNil) ? result_tk_val : @result
+		def alias = (@alias == LiteralNil) ? alias_tk_val : @alias
+	end
+end

data/lib/plume/ast/returning_clause.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Plume
+	class ReturningClause < Node
+		token :returning_kw
+
+		nodes :columns, _Union(ResultColumn, StarResultColumn)
+
+		def self.new(*, columns:, **) = super
+		def self.concrete(*, returning_kw:, columns:, **) = super
+	end
+end

data/lib/plume/ast/rollback_statement.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_transaction.html)**
+	class RollbackStatement < Node
+		token :rollback_kw
+		token :transaction_kw
+		token :name_tk
+		token :to_kw # TO or TO SAVEPOINT
+		token :savepoint_tk
+
+		attribute :savepoint, Stringy
+
+		def self.new(*, **) = super
+		def self.concrete(*, rollback_kw:, **) = super
+
+		def savepoint = (@savepoint == LiteralNil) ? savepoint_tk_val : @savepoint
+	end
+end

data/lib/plume/ast/savepoint_statement.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_savepoint.html)**
+	class SavepointStatement < Node
+		token :savepoint_kw
+		token :name_tk
+
+		attribute :name, Stringy
+
+		def self.new(*, name:, **) = super
+		def self.concrete(*, savepoint_kw:, name_tk:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+	end
+end

data/lib/plume/ast/select_core.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Plume
+	# A single `SELECT … FROM … WHERE … GROUP BY … HAVING … WINDOW …`, without the
+	# statement-level `WITH`, `ORDER BY` and `LIMIT`
+	class SelectCore < Node
+		token :select_kw
+		token :type_tk
+		token :from_kw
+		token :where_kw
+		token :group_by_kw
+		token :having_kw
+		token :window_kw
+
+		nodes :columns, _Union(ResultColumn, StarResultColumn)
+		node :source, _Any
+		node :condition, Expression
+		nodes :groupings, Expression
+		node :having, Expression
+		nodes :windows, WindowDefinition
+
+		def self.new(*, columns:, **) = super
+		def self.concrete(*, select_kw:, columns:, **) = super
+
+		inspectable def distinct = type_tk_tok == :DISTINCT
+	end
+end

data/lib/plume/ast/select_statement.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_select.html)**
+	#
+	# ```sql
+	# with t as (select 1) select * from t union select 2 order by 1 limit 1
+	# ```
+	#
+	# `body` is a `SelectCore`, a `ValuesClause`, or a `CompoundSelect` of those.
+	# `ORDER BY` and `LIMIT` belong to the statement as a whole, not to its last core.
+	class SelectStatement < Node
+		token :order_by_kw
+		token :limit_kw
+		token :offset_tk # OFFSET keyword, or the comma in `LIMIT offset, limit`
+
+		node :with_clause, _Any
+		node :body, _Any
+		nodes :orderings, OrderingTerm
+		node :limit, Expression
+		node :offset, Expression
+
+		def self.new(*, body:, **) = super
+		def self.concrete(*, body:, **) = super
+
+		# Every `SelectCore` and `ValuesClause` making up the body, left to right
+		def cores
+			case body
+			when CompoundSelect then body.cores
+			else [body]
+			end
+		end
+	end
+end

data/lib/plume/ast/star_function_argument.rb

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

data/lib/plume/ast/star_result_column.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Plume
+	class StarResultColumn < Node
+		token :table_tk
+		token :dot_tk
+		token :star_tk
+
+		attribute :table, Stringy
+
+		def self.new(*, **) = super
+		def self.concrete(*, star_tk:, **) = super
+
+		def table = (@table == LiteralNil) ? table_tk_val : @table
+	end
+end

data/lib/plume/ast/strict_table_option.rb

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

data/lib/plume/ast/subquery_expression.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Plume
+	# A scalar subquery `(SELECT …)`, also the right side of `x IN (SELECT …)`
+	class SubqueryExpression < Node
+		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/subquery_source.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Plume
+	# A parenthesized select used as a FROM source, like `(SELECT …) AS s`
+	class SubquerySource < Node
+		token :select_lp
+		token :select_rp
+		token :as_kw
+		token :alias_tk
+
+		node :select, SelectStatement
+		attribute :alias, Stringy
+
+		def self.new(*, select:, **) = super
+		def self.concrete(*, select:, **) = super
+
+		def alias = (@alias == LiteralNil) ? alias_tk_val : @alias
+	end
+end

data/lib/plume/ast/table_constraint.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Plume
+	class TableConstraint < Node
+		# abstract
+	end
+end

data/lib/plume/ast/table_function.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Plume
+	# A table-valued function used as a FROM source, like `json_each(doc) AS j`
+	class TableFunction < Node
+		token :schema_tk
+		token :dot_tk
+		token :function_tk
+		token :arguments_lp
+		token :arguments_rp
+		token :as_kw
+		token :alias_tk
+
+		attribute :schema, Stringy
+		attribute :function, Stringy
+		nodes :arguments, Expression
+		attribute :alias, Stringy
+
+		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
+		def alias = (@alias == LiteralNil) ? alias_tk_val : @alias
+
+		alias_method :name, :function
+	end
+end

data/lib/plume/ast/table_name.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Plume
+	class TableName < Node
+		token :schema_tk
+		token :dot_tk
+		token :table_tk
+		token :as_kw
+		token :alias_tk
+		token :indexed_kw # INDEXED BY, or NOT INDEXED
+		token :index_tk
+
+		attribute :schema, Stringy
+		attribute :table, Stringy
+		attribute :alias, Stringy
+
+		def self.new(*, table:, **) = super
+		def self.concrete(*, table_tk:, **) = super
+
+		def schema = (@schema == LiteralNil) ? schema_tk_val : @schema
+		def table = (@table == LiteralNil) ? table_tk_val : @table
+		def alias = (@alias == LiteralNil) ? alias_tk_val : @alias
+		def indexed_by = index_tk_val
+		def not_indexed = indexed_kw_tok == [:NOT, :INDEXED]
+
+		alias_method :name, :table
+	end
+end

data/lib/plume/ast/table_option.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Plume
+	class TableOption < Node
+		# abstract
+	end
+end

data/lib/plume/ast/ternary_expression.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Plume
+	# `left [NOT] BETWEEN middle AND right`
+	class TernaryExpression < Node
+		TOKEN_TO_OPERATOR = {
+			:BETWEEN                      => :BETWEEN,
+			[:BETWEEN].freeze             => :BETWEEN,
+			[:NOT, :BETWEEN].freeze       => :NOT_BETWEEN,
+		}.freeze
+		Operator = _Union(*TOKEN_TO_OPERATOR.values)
+
+		token :operator_tk
+		token :and_kw
+
+		attribute :operator, Operator
+		node :left, Expression
+		node :middle, Expression
+		node :right, Expression
+
+		def self.new(*, operator:, left:, middle:, right:, **) = super
+		def self.concrete(*, operator_tk:, left:, middle:, right:, **) = super
+
+		def operator = (@operator == LiteralNil) ? TOKEN_TO_OPERATOR[operator_tk_tok] : @operator
+	end
+end