plume 0.2.0 → 0.3.0

data/lib/plume/ast/alter_table_statement.rb

@@ -3,21 +3,30 @@
 module Plume
 	# **[SQLite Docs](https://www.sqlite.org/lang_altertable.html)**
 	#
-	# `action` is :RENAME_TABLE, :RENAME_COLUMN, :ADD_COLUMN or :DROP_COLUMN
+	# `action` is :RENAME_TABLE, :RENAME_COLUMN, :ADD_COLUMN, :DROP_COLUMN, :ADD_CONSTRAINT (a CHECK),
+	# :DROP_CONSTRAINT, :SET_NOT_NULL or :DROP_NOT_NULL
 	class AlterTableStatement < Node
-		Action = _Union(:RENAME_TABLE, :RENAME_COLUMN, :ADD_COLUMN, :DROP_COLUMN)
+		Action = _Union(
+			:RENAME_TABLE, :RENAME_COLUMN, :ADD_COLUMN, :DROP_COLUMN,
+			:ADD_CONSTRAINT, :DROP_CONSTRAINT, :SET_NOT_NULL, :DROP_NOT_NULL,
+		)
 
 		token :alter_table_kw
-		token :action_kw # RENAME [COLUMN], ADD [COLUMN] or DROP [COLUMN]
+		token :action_kw # RENAME [COLUMN], ADD [COLUMN], DROP [COLUMN], DROP CONSTRAINT or ALTER [COLUMN]
 		token :column_tk
 		token :to_kw
 		token :new_name_tk
+		token :constraint_name_tk
+		token :not_null_kw # SET NOT NULL or DROP NOT NULL
 
 		node :table, TableName
 		attribute :action, Action
 		node :column_definition, ColumnDefinition
+		node :constraint, CheckTableConstraint
+		node :conflict_clause, ConflictClause
 		attribute :column, Stringy
 		attribute :new_name, Stringy
+		attribute :constraint_name, Stringy
 
 		def self.new(*, table:, action:, **) = super
 		def self.concrete(*, alter_table_kw:, table:, action:, **) = super
@@ -25,5 +34,7 @@ module Plume
 		def action = @action
 		def column = (@column == LiteralNil) ? column_tk_val : @column
 		def new_name = (@new_name == LiteralNil) ? new_name_tk_val : @new_name
+		# The constraint dropped, or added - which keeps its name on `constraint`
+		def constraint_name = (@constraint_name == LiteralNil) ? (constraint_name_tk_val || constraint&.name) : @constraint_name
 	end
 end

data/lib/plume/ast/check_table_constraint.rb

@@ -10,6 +10,7 @@ module Plume
 
 		attribute :name, Stringy
 		node :expression, Expression
+		node :conflict_clause, ConflictClause
 
 		def self.new(*, expression:, **) = super
 		def self.concrete(*, expression:, **) = super

data/lib/plume/ast/collate_column_constraint.rb

@@ -14,6 +14,6 @@ module Plume
 		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
+		def collation = (@collation == LiteralNil) ? Node.collation_name(collation_tk_val) : @collation
 	end
 end

data/lib/plume/ast/collation_expression.rb

@@ -21,6 +21,6 @@ module Plume
 		end
 
 		def expression = (@expression == LiteralNil) ? expression_tk_val : @expression
-		def sequence = (@sequence == LiteralNil) ? sequence_tk_val.to_sym.upcase : @sequence
+		def sequence = (@sequence == LiteralNil) ? Node.collation_name(sequence_tk_val) : @sequence
 	end
 end

data/lib/plume/ast/column_type.rb

@@ -13,7 +13,8 @@ module Plume
 
 		inspectable def affinity
 			# rules found at: https://www.sqlite.org/datatype3.html#determination_of_column_affinity
-			case text
+			# Matched as bytes, as SQLite does, so a type name that is not valid UTF-8 has one too
+			case text&.b
 			when /INT/i							then	:INTEGER
 			when /CHAR|CLOB|TEXT/i	then	:TEXT
 			when /BLOB/i						then	:BLOB

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/function_arguments.rb

@@ -12,6 +12,7 @@ module Plume
 		def self.new(*, expressions:, **) = super
 		def self.concrete(*, expressions:, **) = super
 
-		def distinct = (@distinct == LiteralNil) ? distinct_kw? : @distinct
+		# 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/indexed_column.rb

@@ -6,16 +6,19 @@ module Plume
 		token :collate_kw
 		token :collation_tk
 		token :direction_tk
+		token :nulls_tk
 
 		attribute :name, Stringy
 		attribute :collation, Stringy
 		attribute :direction, Stringy
+		attribute :nulls, OrderingTerm::Nulls
 
 		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 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_tok&.last : @nulls
 	end
 end

data/lib/plume/ast/node.rb

@@ -6,10 +6,38 @@ module Plume
 
 		Stringy = _Union(String, Symbol)
 
+		def self.literal_properties
+			super
+		rescue => error
+			raise unless defined?(Ractor::IsolationError) && Ractor::IsolationError === error
+
+			raise Ractor::IsolationError, "#{name} is not shareable yet, call Plume.eager_load! from the main Ractor first " \
+				"(or #{name}.make_shareable! for a class defined after it)"
+		end
+
+		def self.make_shareable!
+			Plume.make_shareable(literal_properties)
+			Plume.make_shareable(@inspectable_props)
+			Plume.make_shareable(@token_names)
+			self
+		end
+
+		def self.prop(name, ...)
+			raise FrozenError, "cannot add #{name} to #{self.name} after Plume.eager_load! has frozen its props" if literal_properties.frozen?
+
+			super
+		end
+
+		singleton_class.prepend(LiteralPatches::NodeSchema) if LiteralPatches::SCHEMA_HOLDS_MUTEX
+
 		prop :full_source, _Nilable(String)
 		prop :leading, _Nilable(Token)
 		prop :trailing, _Nilable(Token)
 
+		# A collation's name, upcased as a symbol. A symbol cannot hold bytes that
+		# are not valid UTF-8, so a name with those stays the string it was
+		def self.collation_name(name) = name&.valid_encoding? ? name.to_sym.upcase : name
+
 		def self.inspectable(*props)
 			@inspectable_props ||= Set.new
 			@inspectable_props.merge(props)
@@ -65,16 +93,94 @@ module Plume
 			end
 		end
 
+		# Yields each direct child with the prop it sits in, and its index when that prop holds an array
+		def each_child
+			# Each as one array: TruffleRuby's Enumerator hands only the first of several yielded values to `count`
+			return Enumerator.new { |y| each_child { |*slot| y << slot } } unless block_given?
+
+			self.class.literal_properties.each do |property|
+				case (value = instance_variable_get(:"@#{property.name}"))
+				when Node then yield value, property.name, nil
+				when Array then value.each_with_index { |v, i| yield v, property.name, i if Node === v }
+				end
+			end
+			self
+		end
+
 		# Yields every node in the subtree depth-first, parents before their children,
-		# along with the parent (nil for the receiver)
-		def walk(parent = nil, &block)
-			return enum_for(:walk, parent) unless block
+		# along with the parent (nil for the receiver). Without recursing, so a tree as
+		# deep as SQLite allows does not run out of stack
+		def walk(parent = nil)
+			return enum_for(:walk, parent) unless block_given?
+
+			stack = [[self, parent]]
+			while (node, up = stack.pop)
+				yield node, up
+				node.children.reverse_each { |child| stack << [child, node] }
+			end
+			self
+		end
 
-			yield self, parent
-			children.each { |child| child.walk(self, &block) }
+		# Like `walk`, but also says where under the parent each node sits: the prop's name,
+		# and the index into it when it holds an array
+		def walk_with_slots(parent = nil)
+			return Enumerator.new { |y| walk_with_slots(parent) { |*slot| y << slot } } unless block_given?
+
+			stack = [[self, parent, nil, nil]]
+			while (node, up, prop, index = stack.pop)
+				yield node, up, prop, index
+				start = stack.size
+				node.each_child { |child, name, i| stack << [child, node, name, i] }
+				stack[start..] = stack[start..].reverse
+			end
 			self
 		end
 
+		# A copy of the tree with nodes replaced. The block sees every node as `walk_with_slots` does,
+		# and returns it to keep it, or another node to put in its place - which is not descended into.
+		# Nodes on the way to a replacement are copied, everything else is shared with the original,
+		# which stays as it was. A replacement built with `.new` has no source, so print the result
+		# with `to_sql` rather than reading its `source_text`
+		def transform
+			replaced = {}.compare_by_identity
+			kept = []
+			stack = [[self, nil, nil, nil]]
+			while (node, up, prop, index = stack.pop)
+				replacement = yield node, up, prop, index
+				if replacement.equal?(node)
+					kept << node
+					node.each_child.reverse_each { |child, name, i| stack << [child, node, name, i] }
+				else
+					replaced[node] = replacement
+				end
+			end
+
+			# Parents come before their children in `kept`, so going backwards rebuilds children first
+			kept.reverse_each do |node|
+				changes = {}
+				node.each_child do |child, name, i|
+					next unless replaced.key?(child)
+
+					changes[name] ||= node.instance_variable_get(:"@#{name}").dup if i
+					i ? changes[name][i] = replaced[child] : changes[name] = replaced[child]
+				end
+				replaced[node] = node.with_props(changes) unless changes.empty?
+			end
+			replaced.fetch(self, self)
+		end
+
+		# A copy with some props set to new values, checked against their types
+		def with_props(changes)
+			copy = dup
+			changes.each do |name, value|
+				property = self.class.literal_properties[name]
+				raise TypeError, "#{self.class.name}##{name} cannot be #{value.inspect}" unless property.type === value
+
+				copy.instance_variable_set(:"@#{name}", value)
+			end
+			copy
+		end
+
 		def each_node(&block)
 			return enum_for(:each_node) unless block
 
@@ -93,7 +199,23 @@ module Plume
 			[beg, fin].freeze if beg
 		end
 
-		def to_sql = Printer.print(self)
+		# `pretty: true` lays the SQL out over lines, see PrettyPrinter for `indent_size:`, `max_line_length:`
+		# and `commas_start_of_line:`. With `comments: true`, the comments right before and after the node
+		# in its source come along - a header above a statement, or the sqlcommenter tags after it. Those
+		# inside it are left out. A `--` comment after it becomes a `/* */` one, so a semicolon after it is
+		# not swallowed
+		def to_sql(pretty: false, comments: false, **layout)
+			sql = pretty ? PrettyPrinter.print(self, **layout) : Printer.print(self)
+			return sql unless comments
+
+			before, after = Comments.around(self)
+			lead = before.map { |c| c.text + (c.block? ? " " : "\n") }.join
+			tail = after.map { |c| " #{((c.block? || c.body.include?("*/")) ? c.text : "/*#{c.body} */")}" }.join
+			lead + sql + tail
+		end
+
+		# A plain hash of the whole tree that JSON can carry, which `Plume.load` turns back into it
+		def dump = Dump.dump(self)
 
 		def source_text
 			return unless @full_source && (loc = location)
@@ -195,13 +317,14 @@ module Plume
 			define_node_reader(name)
 		end
 
-		# Absent children read as nil rather than the LiteralNil default
+		# Absent children read as nil rather than the LiteralNil default. Evaluated from a string
+		# because a method defined with a block cannot be called from another Ractor
 		def self.define_node_reader(name)
-			ivar = :"@#{name}"
-			define_method(name) do
-				value = instance_variable_get(ivar)
-				LiteralNil.equal?(value) ? nil : value
-			end
+			class_eval <<-RUBY, __FILE__, __LINE__ + 1
+				def #{name}
+					LiteralNil.equal?(@#{name}) ? nil : @#{name}
+				end
+			RUBY
 		end
 	end
 end

data/lib/plume/ast/ordering_term.rb

@@ -25,7 +25,7 @@ module Plume
 		def self.new(*, **) = super
 		def self.concrete(*, **) = super
 
-		def collation = (@collation == LiteralNil) ? collation_tk_val&.to_sym&.upcase : @collation
+		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

data/lib/plume/ast/token.rb

@@ -148,9 +148,12 @@ module Plume
 			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("''", "'")
+			undoubled(src.byteslice(1, bytesize - 2), "'")
 		end
 
+		# Done on the bytes, since TruffleRuby's gsub refuses a string that is not valid UTF-8
+		def undoubled(text, quote) = text.b.gsub(quote * 2, quote).force_encoding(text.encoding)
+
 		def blob_literal(str, tup)
 			src = source(str, tup)
 			bytesize = src.bytesize
@@ -169,9 +172,9 @@ module Plume
 
 			# 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 96 then undoubled(src.byteslice(1, src.bytesize - 2), "`")
+			when 39 then undoubled(src.byteslice(1, src.bytesize - 2), "'")
+			when 34 then undoubled(src.byteslice(1, src.bytesize - 2), '"')
 			when 91 then src.byteslice(1, src.bytesize - 2)
 			else src
 			end

data/lib/plume/catalog.rb

@@ -1,39 +1,64 @@
 # frozen_string_literal: true
 
 module Plume
-	# What the read analysis knows about a database: its tables with their columns, and its
-	# views. Names are matched case-insensitively, the way SQLite matches identifiers, and
+	# What the read analysis knows about a database: its tables with their columns, its views,
+	# and which table each index and trigger belongs to. Names are matched case-insensitively, the way SQLite matches identifiers, and
 	# reported in the spelling they were declared with.
 	class Catalog
 		ROWID_NAMES = %w[rowid oid _rowid_].freeze
 
 		# `columns` is nil when they cannot be known, like a CREATE TABLE … AS SELECT * from a table
-		# the catalog lacks; any column name is then taken as written
-		Table = Data.define(:schema, :name, :columns, :hidden_columns, :rowid_alias, :without_rowid) do
+		# the catalog lacks; any column name is then taken as written. `generated_columns` are among
+		# `columns` too, since they can be read like any other, but nothing can write to them.
+		# `module_name` is set for a virtual table, like "fts5"
+		Table = Data.define(:schema, :name, :columns, :hidden_columns, :generated_columns, :rowid_alias, :without_rowid, :module_name) do
 			def column(name)
 				return name.to_s unless columns
 
-				needle = name.to_s.downcase
-				columns.find { |c| c.downcase == needle } || hidden_columns.find { |c| c.downcase == needle }
+				needle = name.to_s.downcase(:ascii)
+				columns.find { |c| c.downcase(:ascii) == needle } || hidden_columns.find { |c| c.downcase(:ascii) == needle }
 			end
 
 			def rowid? = !without_rowid
 		end
 
 		View = Data.define(:schema, :name, :columns, :select)
+		Index = Data.define(:schema, :name, :table)
+		Trigger = Data.define(:schema, :name, :table)
 
 		def self.from_sql(sql) = new.load_sql(sql)
 
+		# Whether two names are one to SQLite, which folds the case of A-Z only. Compared as bytes, so a
+		# name that is not valid UTF-8 compares too - JRuby's casecmp? raises for one
+		def self.same_name?(a, b) = !a.nil? && !b.nil? && a.to_s.b.casecmp?(b.to_s.b)
+
+		# The indexes SQLite makes for a table's UNIQUE and PRIMARY KEY constraints, in the order it
+		# makes them - all but the rowid's own primary key, even where two cover the same columns
+		def self.autoindexes(statement)
+			return [] if statement.select_statement
+
+			alias_column = new.__send__(:rowid_alias, statement)&.downcase(:ascii)
+			constraints = statement.columns.flat_map do |column|
+				(column.constraints || []).select { |c| UniqueColumnConstraint === c || (PrimaryKeyColumnConstraint === c && column.name.downcase(:ascii) != alias_column) }
+			end
+			constraints += (statement.constraints || []).select do |c|
+				UniqueTableConstraint === c || (PrimaryKeyTableConstraint === c && !(alias_column && c.columns.size == 1))
+			end
+			Array.new(constraints.size) { |i| "sqlite_autoindex_#{statement.table.name}_#{i + 1}" }
+		end
+
 		# Takes a sqlite3-ruby `SQLite3::Database` (or anything with a compatible `#execute`)
 		def self.from_sqlite(db) = new.load_sqlite(db)
 
 		def initialize
 			@tables = {}
 			@views = {}
+			@indexes = {}
+			@triggers = {}
 		end
 
-		def add_table(name, columns, schema: "main", hidden_columns: [], rowid_alias: nil, without_rowid: false)
-			table = Table.new(schema:, name:, columns: columns.freeze, hidden_columns: hidden_columns.freeze, rowid_alias:, without_rowid:)
+		def add_table(name, columns, schema: "main", hidden_columns: [], generated_columns: [], rowid_alias: nil, without_rowid: false, module_name: nil)
+			table = Table.new(schema:, name:, columns: columns&.freeze, hidden_columns: hidden_columns.freeze, generated_columns: generated_columns.freeze, rowid_alias:, without_rowid:, module_name:)
 			@tables[key(schema, name)] = table
 		end
 
@@ -43,83 +68,147 @@ module Plume
 			@views[key(schema, name)] = View.new(schema:, name:, columns: columns&.freeze, select:)
 		end
 
+		# `table` is the name of the table the index or trigger is on, in the same schema
+		def add_index(name, table, schema: "main") = @indexes[key(schema, name)] = Index.new(schema:, name:, table:)
+		def add_trigger(name, table, schema: "main") = @triggers[key(schema, name)] = Trigger.new(schema:, name:, table:)
+
 		# Unqualified names are looked up the way SQLite does: temp first, then main,
 		# then attached databases in the order they were added
 		def table(name, schema: nil) = lookup(@tables, name, schema)
 		def view(name, schema: nil) = lookup(@views, name, schema)
+		def index(name, schema: nil) = lookup(@indexes, name, schema)
+		def trigger(name, schema: nil) = lookup(@triggers, name, schema)
 
 		def tables = @tables.values
 		def views = @views.values
+		def indexes = @indexes.values
+		def triggers = @triggers.values
 
-		# Statements other than CREATE TABLE and CREATE VIEW (indexes, triggers, inserts…) do not
-		# change what can be read, and are skipped without being parsed
+		# Statements other than CREATE (inserts, pragmas…) do not change the schema, and are skipped
+		# without being parsed
 		def load_sql(sql)
 			Catalog.split_statements(sql).each do |statement_sql|
 				leading = Plume.tokenize(statement_sql).first(3) - [:TEMP, :TEMPORARY]
-				next unless leading[0] == :CREATE && (leading[1] in :TABLE | :VIEW)
+				next unless leading[0] == :CREATE && (leading[1] in :TABLE | :VIEW | :INDEX | :UNIQUE | :TRIGGER | :VIRTUAL)
 
-				case (statement = Parser.new(statement_sql).parse.first)
-				when CreateTableStatement then add_create_table(statement)
-				when CreateViewStatement then add_create_view(statement)
-				end
+				apply(Parser.new(statement_sql).parse.first)
+			end
+			self
+		end
+
+		# Changes the catalog the way running `statement` would change the schema: CREATE adds,
+		# DROP removes, ALTER TABLE renames, adds and drops columns. Other statements change nothing
+		def apply(statement)
+			case statement
+			when CreateTableStatement then add_create_table(statement) unless statement.if_not_exists && table(statement.table.name, schema: statement.table.schema)
+			when CreateViewStatement then add_create_view(statement) unless statement.if_not_exists && view(statement.view.name, schema: statement.view.schema)
+			when CreateVirtualTableStatement
+				add_table(statement.table.name, nil, schema: statement.table.schema || "main", module_name: statement.module_name)
+			when CreateIndexStatement
+				schema = statement.index.schema || table(statement.table)&.schema || "main"
+				add_index(statement.index.name, statement.table, schema:)
+			when CreateTriggerStatement
+				schema = statement.trigger.schema || (statement.temporary ? "temp" : table(statement.table.table)&.schema || "main")
+				add_trigger(statement.trigger.name, statement.table.table, schema:)
+			when DropStatement then drop(statement.type, statement.target)
+			when AlterTableStatement then alter(statement)
 			end
 			self
 		end
 
+		def initialize_copy(other)
+			super
+			@tables = @tables.dup
+			@views = @views.dup
+			@indexes = @indexes.dup
+			@triggers = @triggers.dup
+		end
+
 		def load_sqlite(db)
 			db.execute("PRAGMA database_list").each do |(_seq, schema, _file)|
 				master = (schema == "temp") ? "sqlite_temp_master" : "#{quote(schema)}.sqlite_master"
-				db.execute("SELECT type, name, sql FROM #{master} WHERE type IN ('table', 'view')").each do |(type, name, sql)|
+				db.execute("SELECT type, name, tbl_name, sql FROM #{master} WHERE type IN ('table', 'view', 'index', 'trigger')").each do |(type, name, table, sql)|
 					next if name.start_with?("sqlite_")
 
-					if type == "view"
+					case type
+					when "view"
 						statement = Parser.new(sql).parse.first
 						add_view(name, statement.select, columns: statement.column_names, schema:)
-					else
-						add_sqlite_table(db, schema, name, sql)
+					when "index" then add_index(name, table, schema:)
+					when "trigger" then add_trigger(name, table, schema:)
+					else add_sqlite_table(db, schema, name, sql)
 					end
 				end
 			end
 			self
 		end
 
-		# Splits SQL into statements on top-level semicolons, keeping trigger bodies
-		# (`BEGIN …; …; END`) in one piece
-		def self.split_statements(sql)
-			lexer = Lexer.new(sql, skip_spaces: true)
-			statements = []
-			start = 0
-			recent = []
-			trigger_depth = 0
-			in_trigger = false
-
-			while (token = lexer.next_token)
-				recent = [*recent.last(2), token]
-				in_trigger = true if token == :TRIGGER && recent.include?(:CREATE)
-
-				if in_trigger && token == :BEGIN
-					trigger_depth += 1
-				elsif in_trigger && token == :END && trigger_depth > 0
-					trigger_depth -= 1
-					in_trigger = false if trigger_depth.zero?
-				elsif token == :SEMI && trigger_depth.zero?
-					statements << sql.byteslice(start, lexer.cursor - start)
-					start = lexer.cursor
-				end
+		# Splits SQL into statements, keeping trigger bodies (`BEGIN …; …; END`) in one piece
+		def self.split_statements(sql) = Plume.split(sql)
+
+		private
+
+		def drop(type, target)
+			collection = { TABLE: @tables, VIEW: @views, INDEX: @indexes, TRIGGER: @triggers }.fetch(type)
+			object = lookup(collection, target.table, target.schema) or return
+			collection.delete(key(object.schema, object.name))
+			return unless type == :TABLE || type == :VIEW
+
+			# A table takes its indexes and triggers with it, a view its triggers
+			[@indexes, @triggers].each do |dependents|
+				dependents.delete_if { |_, d| Catalog.same_name?(d.schema, object.schema) && Catalog.same_name?(d.table, object.name) }
 			end
-			statements << sql.byteslice(start, sql.bytesize - start)
-			statements.reject { |s| Plume.tokenize(s).reject { |t| t == :SEMI }.empty? }
 		end
 
-		private
+		def alter(statement)
+			table = table(statement.table.table, schema: statement.table.schema) or return
+			columns = table.columns
+			rename = -> (list, from, to) { list&.map { |c| Catalog.same_name?(c, from) ? to : c } }
+
+			changed =
+				case statement.action
+				when :RENAME_TABLE then return rename_table(table, statement.new_name)
+				when :ADD_COLUMN
+					definition = statement.column_definition
+					generated = definition.constraints&.any?(GeneratedAsColumnConstraint)
+					table.with(columns: columns && [*columns, definition.name].freeze, generated_columns: generated ? [*table.generated_columns, definition.name].freeze : table.generated_columns)
+				when :RENAME_COLUMN
+					from, to = statement.column, statement.new_name
+					table.with(
+						columns: rename.(columns, from, to)&.freeze, generated_columns: rename.(table.generated_columns, from, to).freeze,
+						rowid_alias: Catalog.same_name?(table.rowid_alias, from) ? to : table.rowid_alias,
+					)
+				when :DROP_COLUMN
+					gone = -> (list) { list&.reject { |c| Catalog.same_name?(c, statement.column) }&.freeze }
+					table.with(columns: gone.(columns), generated_columns: gone.(table.generated_columns))
+				else return
+				end
+			@tables[key(table.schema, table.name)] = changed
+		end
+
+		def rename_table(table, new_name)
+			@tables.delete(key(table.schema, table.name))
+			@tables[key(table.schema, new_name)] = table.with(name: new_name)
+			old_prefix = "sqlite_autoindex_#{table.name}_"
+			@indexes.transform_values! { |i| (Catalog.same_name?(i.schema, table.schema) && Catalog.same_name?(i.table, table.name)) ? i.with(table: new_name) : i }
+			@indexes.keys.each do |k|
+				index = @indexes[k]
+				next unless index.name.start_with?(old_prefix) && index.table == new_name
+
+				@indexes.delete(k)
+				renamed = index.with(name: index.name.sub(old_prefix, "sqlite_autoindex_#{new_name}_"))
+				@indexes[key(renamed.schema, renamed.name)] = renamed
+			end
+			@triggers.transform_values! { |t| (Catalog.same_name?(t.schema, table.schema) && Catalog.same_name?(t.table, table.name)) ? t.with(table: new_name) : t }
+		end
 
-		def key(schema, name) = [schema.to_s.downcase, name.to_s.downcase].freeze
+		def key(schema, name) = [schema.to_s.downcase(:ascii), name.to_s.downcase(:ascii)].freeze
 
 		def lookup(collection, name, schema)
 			return collection[key(schema, name)] if schema
 
 			collection[key("temp", name)] || collection[key("main", name)] ||
-				collection.find { |(_s, n), _| n == name.to_s.downcase }&.last
+				collection.find { |(_s, n), _| n == name.to_s.downcase(:ascii) }&.last
 		end
 
 		def schema_of(name, statement) = name.schema || (statement.temporary ? "temp" : "main")
@@ -135,7 +224,9 @@ module Plume
 			end
 
 			columns = statement.columns.map(&:name)
-			add_table(name, columns, schema:, rowid_alias: rowid_alias(statement), without_rowid: statement.without_row_id)
+			generated = statement.columns.select { |c| c.constraints&.any?(GeneratedAsColumnConstraint) }.map(&:name)
+			add_table(name, columns, schema:, generated_columns: generated, rowid_alias: rowid_alias(statement), without_rowid: statement.without_row_id)
+			Catalog.autoindexes(statement).each { |index| add_index(index, name, schema:) }
 		end
 
 		def add_create_view(statement)
@@ -155,12 +246,12 @@ module Plume
 			unless candidate
 				table_pk = statement.constraints&.find { |c| PrimaryKeyTableConstraint === c }
 				if table_pk && table_pk.columns.size == 1
-					pk_name = table_pk.columns[0].name.downcase
-					candidate = statement.columns.find { |c| c.name.downcase == pk_name }
+					pk_name = table_pk.columns[0].name.downcase(:ascii)
+					candidate = statement.columns.find { |c| c.name.downcase(:ascii) == pk_name }
 				end
 			end
 
-			candidate.name if candidate&.type&.text&.casecmp?("INTEGER")
+			candidate.name if Catalog.same_name?(candidate&.type&.text, "INTEGER")
 		end
 
 		def add_sqlite_table(db, schema, name, sql)
@@ -168,11 +259,16 @@ module Plume
 			# hidden is 0 for ordinary columns, 1 for hidden virtual table columns, 2 and 3 for generated ones
 			columns = info.reject { |row| row[6] == 1 }.map { |row| row[1] }
 			hidden = info.select { |row| row[6] == 1 }.map { |row| row[1] }
+			generated = info.select { |row| row[6] == 2 || row[6] == 3 }.map { |row| row[1] }
 			without_rowid = sql.to_s.match?(/\bWITHOUT\s+ROWID\s*;?\s*\z/i)
 			pk_rows = info.select { |row| row[5].to_i > 0 }
-			rowid_alias = pk_rows[0][1] if !without_rowid && pk_rows.size == 1 && pk_rows[0][2].to_s.casecmp?("INTEGER")
+			rowid_alias = pk_rows[0][1] if !without_rowid && pk_rows.size == 1 && Catalog.same_name?(pk_rows[0][2].to_s, "INTEGER")
 
-			add_table(name, columns, schema:, hidden_columns: hidden, rowid_alias:, without_rowid:)
+			statement = Parser.new(sql).parse.first
+			module_name = statement.module_name if CreateVirtualTableStatement === statement
+			add_table(name, columns, schema:, hidden_columns: hidden, generated_columns: generated, rowid_alias:, without_rowid:, module_name:)
+			# The schema has no row for a WITHOUT ROWID table's primary key, though SQLite counts it as an index
+			Catalog.autoindexes(statement).each { |index| add_index(index, name, schema:) } if CreateTableStatement === statement
 		end
 
 		def quote(identifier) = %("#{identifier.to_s.gsub('"', '""')}")