plume 0.1.0 → 0.2.0

data/lib/plume/ast/alter_table_statement.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_altertable.html)**
+	#
+	# `action` is :RENAME_TABLE, :RENAME_COLUMN, :ADD_COLUMN or :DROP_COLUMN
+	class AlterTableStatement < Node
+		Action = _Union(:RENAME_TABLE, :RENAME_COLUMN, :ADD_COLUMN, :DROP_COLUMN)
+
+		token :alter_table_kw
+		token :action_kw # RENAME [COLUMN], ADD [COLUMN] or DROP [COLUMN]
+		token :column_tk
+		token :to_kw
+		token :new_name_tk
+
+		node :table, TableName
+		attribute :action, Action
+		node :column_definition, ColumnDefinition
+		attribute :column, Stringy
+		attribute :new_name, Stringy
+
+		def self.new(*, table:, action:, **) = super
+		def self.concrete(*, alter_table_kw:, table:, action:, **) = super
+
+		def action = @action
+		def column = (@column == LiteralNil) ? column_tk_val : @column
+		def new_name = (@new_name == LiteralNil) ? new_name_tk_val : @new_name
+	end
+end

data/lib/plume/ast/analyze_statement.rb

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

data/lib/plume/ast/assignment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Plume
+	# One `col = expr` or `(a, b) = expr` from a SET list
+	class Assignment < Node
+		token :columns_lp
+		token :columns_rp
+		token :eq_tk
+
+		nodes :columns, ColumnName
+		node :value, Expression
+
+		def self.new(*, columns:, value:, **) = super
+		def self.concrete(*, columns:, value:, **) = super
+
+		def column_names = columns.map(&:column)
+	end
+end

data/lib/plume/ast/attach_statement.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_attach.html)**
+	class AttachStatement < Node
+		token :attach_kw # ATTACH or ATTACH DATABASE
+		token :as_kw
+		token :key_kw
+
+		node :file, Expression
+		node :schema, Expression
+		node :key, Expression
+
+		def self.new(*, file:, schema:, **) = super
+		def self.concrete(*, attach_kw:, file:, schema:, **) = super
+	end
+end

data/lib/plume/ast/begin_statement.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_transaction.html)**
+	class BeginStatement < Node
+		token :begin_kw
+		token :type_kw
+		token :transaction_kw
+		token :name_tk
+
+		def self.new(*, **) = super
+		def self.concrete(*, begin_kw:, **) = super
+
+		# :DEFERRED, :IMMEDIATE, :EXCLUSIVE, or nil for SQLite's default (deferred)
+		inspectable def type = type_kw_tok
+	end
+end

data/lib/plume/ast/binary_expression.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Plume
+	class BinaryExpression < Node
+		TOKEN_TO_OPERATOR = {
+			:AND                                 => :ALL,
+			:OR                                  => :ANY,
+			:CONCAT                              => :CONCAT,
+			:PTR1                                => :EXTRACT,
+			:PTR2                                => :RETRIEVE,
+			:STAR                                => :MULTIPLY,
+			:SLASH                               => :DIVIDE,
+			:REM                                 => :MODULO,
+			:PLUS                                => :ADD,
+			:MINUS                               => :SUB,
+			:BITAND                              => :BIT_AND,
+			:BITOR                               => :BIT_OR,
+			:LSHIFT                              => :BIT_LSHIFT,
+			:RSHIFT                              => :BIT_RSHIFT,
+			:LT                                  => :BELOW,
+			:GT                                  => :ABOVE,
+			:LE                                  => :ATMOST,
+			:GE                                  => :ATLEAST,
+			:EQ                                  => :EQUALS,
+			:NE                                  => :NOT_EQUALS,
+			:IS                                  => :IS,
+			:GLOB                                => :GLOB,
+			:REGEXP                              => :REGEXP,
+			:MATCH                               => :MATCH,
+			:IN                                  => :IN,
+			[:IS, :NOT, :DISTINCT, :FROM].freeze => :IS,
+			[:IS, :DISTINCT, :FROM].freeze       => :IS_NOT,
+			[:IS, :NOT].freeze                   => :IS_NOT,
+			[:IS].freeze                         => :IS,
+			[:GLOB].freeze                       => :GLOB,
+			[:REGEXP].freeze                     => :REGEXP,
+			[:MATCH].freeze                      => :MATCH,
+			[:IN].freeze                         => :IN,
+			[:NOT, :GLOB].freeze                 => :NOT_GLOB,
+			[:NOT, :REGEXP].freeze               => :NOT_REGEXP,
+			[:NOT, :MATCH].freeze                => :NOT_MATCH,
+			[:NOT, :IN].freeze                   => :NOT_IN,
+		}.freeze
+		Operator = _Union(*TOKEN_TO_OPERATOR.values)
+
+		token :operator_tk         # required
+		token :left_tk             # required
+		token :right_tk            # required
+
+		attribute :operator, Operator   # required
+		attribute :left,     Expression # required
+		attribute :right,    Expression # required
+
+		def self.new(*, operator:, left:, right:, **) = super
+		def self.concrete(*, operator_tk:, **) = super
+
+		# Parser may pass either tokens or attributes, so
+		# require none in `concrete` signature but ensure presence here.
+		def after_initialize
+			if @left.nil? && @left_tk.nil?
+				raise ArgumentError.new("missing either: :left, :left_tk")
+			elsif @right.nil? && @right_tk.nil?
+				raise ArgumentError.new("missing either: :right, :right_tk")
+			end
+		end
+
+		def operator = (@operator == LiteralNil) ? TOKEN_TO_OPERATOR[operator_tk_tok] : @operator
+		def left = (@left == LiteralNil) ? left_tk_val : @left
+		def right = (@right == LiteralNil) ? right_tk_val : @right
+	end
+end

data/lib/plume/ast/case_condition.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Plume
+	class CaseCondition < Node
+		token :when_kw
+		token :predicate_tk
+		token :then_kw
+		token :consequence_tk
+
+		attribute :predicate, Expression
+		attribute :consequence, Expression
+
+		def self.new(*, predicate:, consequence:, **) = super
+		def self.concrete(*, when_kw:, then_kw:, **) = super
+
+		# Parser may pass either tokens or attributes, so
+		# require none in `concrete` signature but ensure presence here.
+		def after_initialize
+			if @predicate.nil? && @predicate_tk.nil?
+				raise ArgumentError.new("missing either: :predicate, :predicate_tk")
+			elsif @consequence.nil? && @consequence_tk.nil?
+				raise ArgumentError.new("missing either: :consequence, :consequence_tk")
+			end
+		end
+
+		def predicate = (@predicate == LiteralNil) ? predicate_tk_val : @predicate
+		def consequence = (@consequence == LiteralNil) ? consequence_tk_val : @consequence
+	end
+end

data/lib/plume/ast/case_expression.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Plume
+	class CaseExpression < Node
+		token :case_kw
+		token :predicate_tk
+		token :else_kw
+		token :else_clause_tk
+		token :end_kw
+
+		attribute :predicate, Expression
+		attribute :else_clause, Expression
+
+		nodes :conditions, CaseCondition
+
+		def self.new(*, conditions:, **) = super
+		def self.concrete(*, case_kw:, conditions:, end_kw:, **) = super
+
+		def predicate = (@predicate == LiteralNil) ? predicate_tk_val : @predicate
+		def else_clause = (@else_clause == LiteralNil) ? else_clause_tk_val : @else_clause
+	end
+end

data/lib/plume/ast/cast_expression.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Plume
+	class CastExpression < Node
+		token :cast_kw
+		token :expression_lp
+		token :as_kw
+		token :expression_rp
+
+		node :expression, Expression
+		node :as, ColumnType
+
+		def self.new(*, expression:, as:, **) = super
+		def self.concrete(*, cast_kw:, expression_lp:, expression:, as_kw:, as:, expression_rp:, **) = super
+	end
+end

data/lib/plume/ast/check_column_constraint.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Plume
+	class CheckColumnConstraint < ColumnConstraint
+		token :constraint_kw
+		token :name_tk
+		token :check_kw
+		token :check_lp
+		token :check_rp
+
+		attribute :name, Stringy
+		node :expression, Expression
+		node :conflict_clause, ConflictClause
+
+		def self.new(*, expression:, **) = super
+		def self.concrete(*, check_kw:, check_lp:, expression:, check_rp:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+	end
+end

data/lib/plume/ast/check_table_constraint.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Plume
+	class CheckTableConstraint < TableConstraint
+		token :constraint_kw
+		token :name_tk
+		token :check_kw
+		token :check_lp
+		token :check_rp
+
+		attribute :name, Stringy
+		node :expression, Expression
+
+		def self.new(*, expression:, **) = super
+		def self.concrete(*, expression:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+	end
+end

data/lib/plume/ast/collate_column_constraint.rb

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

data/lib/plume/ast/collation_expression.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Plume
+	class CollationExpression < Node
+		token :collate_kw
+		token :expression_tk
+		token :sequence_tk
+
+		attribute :expression, Expression
+		attribute :sequence, Stringy
+
+		def self.new(*, sequence:, **) = super
+		def self.concrete(*, sequence_tk:, **) = super
+
+		# Parser may pass either tokens or attributes, so
+		# require none in `concrete` signature but ensure presence here.
+		def after_initialize
+			if @expression.nil? && @expression_tk.nil?
+				raise ArgumentError.new("missing either: :expression, :expression_tk")
+			end
+		end
+
+		def expression = (@expression == LiteralNil) ? expression_tk_val : @expression
+		def sequence = (@sequence == LiteralNil) ? sequence_tk_val.to_sym.upcase : @sequence
+	end
+end

data/lib/plume/ast/column_constraint.rb

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

data/lib/plume/ast/column_definition.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Plume
+	class ColumnDefinition < Node
+		token :name_tk
+
+		attribute :name, Stringy
+		node :type, ColumnType
+		nodes :constraints, ColumnConstraint
+
+		def self.new(*, name:, **) = super
+		def self.concrete(*, name_tk:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+	end
+end

data/lib/plume/ast/column_name.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Plume
+	class ColumnName < Node
+		token :schema_tk # maybe
+		token :dot1 # maybe
+		token :table_tk # maybe
+		token :dot2 # maybe
+		token :column_tk # required
+
+		attribute :schema, Stringy # maybe
+		attribute :table, Stringy # maybe
+		attribute :column, Stringy # required
+
+		def self.new(*, column:, **) = super
+		def self.concrete(*, column_tk:, **) = super
+
+		def schema = (@schema == LiteralNil) ? schema_tk_val : @schema
+		def table = (@table == LiteralNil) ? table_tk_val : @table
+		def column = (@column == LiteralNil) ? column_tk_val : @column
+	end
+end

data/lib/plume/ast/column_type.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Plume
+	class ColumnType < Node
+		token :text_span
+
+		attribute :text, Stringy
+
+		def self.new(*, text:, **) = super
+		def self.concrete(*, text_span:, **) = super
+
+		def text = (@text == LiteralNil) ? text_span_val : @text
+
+		inspectable def affinity
+			# rules found at: https://www.sqlite.org/datatype3.html#determination_of_column_affinity
+			case text
+			when /INT/i							then	:INTEGER
+			when /CHAR|CLOB|TEXT/i	then	:TEXT
+			when /BLOB/i						then	:BLOB
+			when /REAL|FLOA|DOUB/i	then	:REAL
+			else													:ANY
+			end
+		end
+	end
+end

data/lib/plume/ast/commit_statement.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Plume
+	# COMMIT or END. **[SQLite Docs](https://www.sqlite.org/lang_transaction.html)**
+	class CommitStatement < Node
+		token :commit_kw
+		token :transaction_kw
+		token :name_tk
+
+		def self.new(*, **) = super
+		def self.concrete(*, commit_kw:, **) = super
+	end
+end

data/lib/plume/ast/common_table_expression.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Plume
+	class CommonTableExpression < Node
+		token :name_tk
+		token :columns_lp
+		token :columns_rp
+		token :as_kw
+		token :materialized_tk
+		token :select_lp
+		token :select_rp
+
+		attribute :name, Stringy
+		nodes :columns, IndexedColumn
+		node :select, SelectStatement
+
+		def self.new(*, name:, select:, **) = super
+		def self.concrete(*, name_tk:, select:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+		def column_names = columns&.map(&:name)
+
+		# true for MATERIALIZED, false for NOT MATERIALIZED, nil when left to the planner
+		inspectable def materialized
+			case materialized_tk_tok
+			when :MATERIALIZED then true
+			when [:NOT, :MATERIALIZED] then false
+			end
+		end
+	end
+end

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