plume 0.1.0 → 0.2.0

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

data/lib/plume/ast/token.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Plume
+	module Token
+		extend Literal::Types
+		extend self
+
+		Type = _Union(
+			:keyword,
+			:identifier,
+			:punctuation,
+			:string,
+			:numeric,
+			:blob,
+			:true,
+			:false,
+			:null,
+			:current,
+			:variable,
+		)
+
+		Tuple = _Tuple(_Union(Symbol, _Array(Symbol)), Integer, Integer, Type)
+
+		def Keyword(arg)
+			[*arg, :keyword] if arg
+		end
+
+		def Identifier(arg)
+			[*arg, :identifier] if arg
+		end
+
+		def Punctuation(arg)
+			[*arg, :punctuation] if arg
+		end
+
+		def String(arg)
+			[*arg, :string] if arg
+		end
+
+		def Numeric(arg)
+			[*arg, :numeric] if arg
+		end
+
+		def Blob(arg)
+			[*arg, :blob] if arg
+		end
+
+		def True(arg)
+			[*arg, :true] if arg
+		end
+
+		def False(arg)
+			[*arg, :false] if arg
+		end
+
+		def Null(arg)
+			[*arg, :null] if arg
+		end
+
+		def Current(arg)
+			[*arg, :current] if arg
+		end
+
+		def Variable(arg)
+			[*arg, :variable] if arg
+		end
+
+		def source(str, tup)
+			return unless str && present?(tup)
+
+			_, beg, fin, = tup
+
+			str.byteslice(beg, (fin - beg))
+		end
+
+		def value(str, tup)
+			return unless str && present?(tup)
+
+			*, type = tup
+
+			case type
+			when :null        then LiteralNil
+			when :true        then true
+			when :false       then LiteralFalse
+			when :current     then source(str, tup).to_sym.upcase
+			when :numeric     then numeric_literal(str, tup)
+			when :string      then string_literal(str, tup)
+			when :blob        then blob_literal(str, tup)
+			when :keyword     then source(str, tup)
+			when :identifier  then identifier(str, tup)
+			when :punctuation then source(str, tup)
+			when :variable    then source(str, tup)
+			end
+		end
+
+		def location(tup)
+			return unless present?(tup)
+
+			_, beg, fin, = tup
+
+			[beg, fin].freeze
+		end
+
+		def token(tup)
+			return unless present?(tup)
+
+			tok, * = tup
+
+			tok
+		end
+
+		def ===(other)
+			Tuple === other
+		end
+
+		private
+
+		def present?(tup) = !(tup.nil? || LiteralNil.equal?(tup))
+
+		def numeric_literal(str, tup)
+			tok, * = tup
+			src = source(str, tup)
+
+			case tok
+			when :INTEGER, [:PLUS, :INTEGER], [:MINUS, :INTEGER]
+				integer_literal(src)
+			when :FLOAT, [:PLUS, :FLOAT], [:MINUS, :FLOAT]
+				src.to_f
+			when :QNUMBER, [:PLUS, :QNUMBER], [:MINUS, :QNUMBER]
+				(src.match?(/[.eE]/) && !src.match?(/0x/i)) ? src.delete("_").to_f : integer_literal(src)
+			end
+		end
+
+		def integer_literal(src)
+			digits = src.delete("_").delete_prefix("+")
+			negative = digits.delete_prefix!("-")
+			value = digits.match?(/\A0x/i) ? hex_literal(digits) : digits.to_i
+			negative ? -value : value
+		end
+
+		# SQLite reads a hex literal as a 64-bit two's-complement integer, so 0xFFFFFFFFFFFFFFFF is -1
+		def hex_literal(digits)
+			value = digits.to_i(16)
+			(value >= (2**63)) ? value - (2**64) : value
+		end
+
+		def string_literal(str, tup)
+			src = source(str, tup)
+			bytesize = src.bytesize
+			# strip the leading and trailing quotes, a quote inside is written twice
+			src.byteslice(1, bytesize - 2).gsub("''", "'")
+		end
+
+		def blob_literal(str, tup)
+			src = source(str, tup)
+			bytesize = src.bytesize
+			# trim the leading /x'/i and trailing /'/ then decode the hexadecimal string
+			[src.byteslice(2, bytesize - 3)].pack("H*")
+		end
+
+		def identifier(str, tup)
+			tok, * = tup
+
+			return string_literal(str, tup) if tok == :STRING
+
+			src = source(str, tup)
+
+			return src if tok != :ID
+
+			# Inside quotes, the quote character itself is written twice. Brackets have no escape
+			case src.getbyte(0)
+			when 96 then src.byteslice(1, src.bytesize - 2).gsub("``", "`")
+			when 39 then src.byteslice(1, src.bytesize - 2).gsub("''", "'")
+			when 34 then src.byteslice(1, src.bytesize - 2).gsub('""', '"')
+			when 91 then src.byteslice(1, src.bytesize - 2)
+			else src
+			end
+		end
+	end
+end

data/lib/plume/ast/unary_expression.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Plume
+	class UnaryExpression < Node
+		TOKEN_TO_OPERATOR = {
+			:BITNOT => :INVERT,
+			:PLUS => :IDENTITY,
+			:MINUS => :NEGATE,
+			:NOT => :NOT,
+			:ISNULL => :IS_NULL,
+			:NOTNULL => :NOT_NULL,
+			[:NOT, :NULL].freeze => :NOT_NULL,
+		}.freeze
+		Operator = _Union(*TOKEN_TO_OPERATOR.values)
+
+		token :operator_tk         # required
+		token :operand_tk          # required
+
+		attribute :operator, Operator   # required
+		attribute :operand,  Expression # required
+
+		def self.new(*, operator:, operand:, **) = 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 @operand.nil? && @operand_tk.nil?
+				raise ArgumentError.new("missing either: :operand, :operand_tk")
+			end
+		end
+
+		def operator = (@operator == LiteralNil) ? TOKEN_TO_OPERATOR[operator_tk_tok] : @operator
+		def operand = (@operand == LiteralNil) ? operand_tk_val : @operand
+	end
+end

data/lib/plume/ast/unique_column_constraint.rb

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

data/lib/plume/ast/unique_table_constraint.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Plume
+	class UniqueTableConstraint < TableConstraint
+		token :constraint_kw
+		token :name_tk
+		token :unique_kw
+		token :unique_lp
+		token :unique_rp
+
+		attribute :name, Stringy
+		nodes :columns, IndexedColumn
+		node :conflict_clause, ConflictClause
+
+		def self.new(*, columns:, **) = super
+		def self.concrete(*, columns:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+	end
+end

data/lib/plume/ast/update_statement.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_update.html)**
+	#
+	# ```sql
+	# update or ignore t as x set a = u.a from u where u.id = x.id returning x.a
+	# ```
+	class UpdateStatement < Node
+		include ConflictResolution
+
+		token :update_kw # UPDATE [OR …]
+		token :set_kw
+		token :from_kw
+		token :where_kw
+		token :order_by_kw
+		token :limit_kw
+		token :offset_tk
+
+		node :with_clause, WithClause
+		node :table, TableName
+		nodes :assignments, Assignment
+		node :source, _Any
+		node :condition, Expression
+		node :returning, ReturningClause
+		nodes :orderings, OrderingTerm
+		node :limit, Expression
+		node :offset, Expression
+
+		def self.new(*, table:, assignments:, **) = super
+		def self.concrete(*, update_kw:, table:, assignments:, **) = super
+
+		inspectable def or_action = TOKEN_TO_RESOLUTION[update_kw_tok]
+	end
+end

data/lib/plume/ast/upsert_clause.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Plume
+	# `ON CONFLICT [(target) [WHERE …]] DO NOTHING | DO UPDATE SET … [WHERE …]`
+	class UpsertClause < Node
+		token :on_conflict_kw
+		token :target_lp
+		token :target_rp
+		token :target_where_kw
+		token :do_kw
+		token :action_kw
+		token :set_kw
+		token :where_kw
+
+		nodes :targets, OrderingTerm
+		node :target_condition, Expression
+		nodes :assignments, Assignment
+		node :condition, Expression
+
+		def self.new(*, **) = super
+		def self.concrete(*, on_conflict_kw:, action_kw:, **) = super
+
+		# :NOTHING or :UPDATE
+		inspectable def action = action_kw_tok
+	end
+end

data/lib/plume/ast/vacuum_statement.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Plume
+	# **[SQLite Docs](https://www.sqlite.org/lang_vacuum.html)**
+	class VacuumStatement < Node
+		token :vacuum_kw
+		token :schema_tk
+		token :into_kw
+
+		attribute :schema, Stringy
+		node :into, Expression
+
+		def self.new(*, **) = super
+		def self.concrete(*, vacuum_kw:, **) = super
+
+		def schema = (@schema == LiteralNil) ? schema_tk_val : @schema
+	end
+end

data/lib/plume/ast/values_clause.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Plume
+	class ValuesClause < Node
+		token :values_kw
+
+		nodes :rows, ValuesRow
+
+		def self.new(*, rows:, **) = super
+		def self.concrete(*, values_kw:, rows:, **) = super
+	end
+end

data/lib/plume/ast/values_row.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Plume
+	class ValuesRow < Node
+		token :row_lp
+		token :row_rp
+
+		nodes :values, Expression
+
+		def self.new(*, values:, **) = super
+		def self.concrete(*, values:, **) = super
+	end
+end

data/lib/plume/ast/variable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plume
+	# A bind parameter: `?`, `?1`, `:name`, `@name` or `$name`
+	class Variable < Node
+		token :name_tk
+
+		attribute :name, Stringy
+
+		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/window_definition.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Plume
+	# A named window from the `WINDOW` clause of a select core
+	class WindowDefinition < Node
+		token :name_tk
+		token :as_kw
+		token :window_lp
+		token :base_window_name_tk
+		token :partition_by_kw
+		token :order_by_kw
+		token :window_rp
+
+		attribute :name, Stringy
+		attribute :base_window_name, Stringy
+		nodes :partitions, Expression
+		nodes :orderings, OrderingTerm
+		node :frame, FrameSpec
+
+		def self.new(*, name:, **) = super
+		def self.concrete(*, name_tk:, **) = super
+
+		def name = (@name == LiteralNil) ? name_tk_val : @name
+		def base_window_name = (@base_window_name == LiteralNil) ? base_window_name_tk_val : @base_window_name
+	end
+end

data/lib/plume/ast/with_clause.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plume
+	class WithClause < Node
+		token :with_kw
+		token :recursive_kw
+
+		nodes :ctes, CommonTableExpression
+
+		def self.new(*, ctes:, **) = super
+		def self.concrete(*, with_kw:, ctes:, **) = super
+
+		inspectable def recursive = recursive_kw?
+	end
+end

data/lib/plume/ast/without_rowid_table_option.rb

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