lowdata 0.1.0 → 0.3.0

data/lib/nesting_path.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+class LowData
+  # Lays out a + chain for NestingTree. Each operand nests in the operand before it, and an array nests its expressions
+  # side by side in the table before it, ending the chain:
+  #   Users + Posts + Comments                # comments in posts, in users
+  #   Users + [Posts + Comments, Likes]       # posts with their comments, and likes, in users
+  #   Users + Posts + Likes(:user_id)         # a named foreign key reaches back: likes in users, beside posts
+  # Foreign keys only link adjacent tables, so a foreign key between other tables can't change or break the chain.
+  class NestingPath
+    ARRAY_END_MESSAGE = 'An array ends a + chain, because it nests several tables. Put the rest of the chain in the ' \
+                        'array, e.g. Users + [Posts + Comments, Orders]'
+
+    # A node waiting for its children to be linked, and the entries from it down to the end of its chain.
+    Entry = Struct.new(:node, :children, :tail, :closed) do
+      def self.for(node) = new(node, [], nil, false)
+
+      def path = self[:tail] || [self]
+
+      def tables = node.tables
+    end
+
+    def initialize(schema:, tree:)
+      @schema = schema
+      @tree = tree
+    end
+
+    # A + chain is left deep, and + is associative, so a parenthesised chain's operands join the path.
+    def self.segments(node:)
+      return [node] unless node.is_a?(DataExpression::Join) && node.nest?
+
+      segments(node: node.left) + segments(node: node.right)
+    end
+
+    # Returns the first segment's entry, with every other segment nested under it.
+    def chain(segments:)
+      root = @tree.entry(node: segments.first)
+      path = segments.drop(1).reduce(root.path) { |entries, segment| attach(path: entries, segment:) }
+      root.tap { |entry| entry.tail = path }
+    end
+
+    private
+
+    # Nests a segment and returns the path to the end of the chain.
+    def attach(path:, segment:)
+      raise JoinError, ARRAY_END_MESSAGE if path.last.closed
+      return siblings(path:, nodes: segment.nodes) if segment.is_a?(DataExpression::Siblings)
+
+      child = @tree.entry(node: segment)
+      parent = parent(path:, child:)
+      parent.children << child
+      path[0..path.index { |entry| entry.equal?(parent) }] + child.path
+    end
+
+    def siblings(path:, nodes:)
+      nodes.each { |node| path.last.children << @tree.entry(node:) }
+      path.last.closed = true
+      path
+    end
+
+    # The tables before the last, nearest first.
+    def earlier(path:) = path[0...-1].reverse
+
+    # The table before, unless a foreign key named in the child's round brackets points to an earlier one.
+    def parent(path:, child:)
+      targets = named_targets(child:)
+      tables = targets.map(&:last)
+      return linked!(path:, child:) if tables.empty? || (path.last.tables & tables).any?
+
+      earlier(path:).find { |entry| (entry.tables & tables).any? } ||
+        raise(JoinError, "#{targets.first.first} points to #{tables.first}, which isn't earlier in this + chain")
+    end
+
+    # Each foreign key named in the child's round brackets, as `table.column` and the table it points to. A key between
+    # a join's own tables links the join, not the chain, so it's left out.
+    def named_targets(child:)
+      child.node.foreign_keys.flat_map do |table, columns|
+        keys = @schema.foreign_keys(table:).select { |key| (key[:columns] & columns).any? && !child.tables.include?(key[:table]) }
+        keys.map { |key| ["#{table}.#{key[:columns].first}", key[:table]] }
+      end
+    end
+
+    # The table before, when a foreign key links the two. Otherwise it suggests nesting the child in an earlier table.
+    def linked!(path:, child:)
+      parent = path.last
+      raise JoinError, "Can't nest #{parent.tables.join(', ')} in itself" if parent.tables == child.tables
+      return parent if linked?(child, parent)
+
+      earlier = earlier(path:).find { |entry| linked?(child, entry) }
+      raise JoinError, unlinked_message(child: child.tables.first, parent: parent.tables.last, earlier: earlier&.tables&.last)
+    end
+
+    def linked?(entry, other)
+      entry.tables.product(other.tables).any? { |table, other_table| @schema.linked?(table, other_table) }
+    end
+
+    # Suggests an array, or naming the foreign key that reaches back to the earlier table.
+    def unlinked_message(child:, parent:, earlier:)
+      message = "No foreign key links #{child} to #{parent}"
+      return message unless earlier
+
+      names = [earlier, parent, child].map { |table| LowData.constant_name(table) }
+      key = @schema.links(from: child, to: earlier).first
+      "#{message}. To nest #{child} in #{earlier}, beside #{parent}, write #{names[0]} + [#{names[1]}, #{names[2]}]" +
+        (key ? " or name its foreign key: #{names[2]}(:#{key[:columns].first})" : '')
+    end
+  end
+end

data/lib/nesting_tree.rb

@@ -1,113 +1,98 @@
 # frozen_string_literal: true
 
 class LowData
-  # Builds the tree Nesting loads from an expression. Tables in brackets nest directly under their table, and the
-  # operands of a + chain nest by following foreign keys from the first operand.
+  # Builds the tree Nesting loads from an expression. Tables in brackets nest directly under their table, and each
+  # operand of a + chain nests in the operand before it: see NestingPath. A join nests as flat rows: see NestedJoin.
   class NestingTree
-    MULTIPLE_PATHS_MESSAGE = 'Foreign keys link %<tables>s by more than one path, so + has no single way to nest them. ' \
-                             'Nest them in brackets instead, e.g. Users[:username, Posts[:title, Likes[]]]'
-
     def initialize(schema:)
       @schema = schema
+      @path = NestingPath.new(schema:, tree: self)
     end
 
-    # Builds the tree for an expression: a table with any tables nested in its brackets, or a + chain.
     def build(node:)
+      assemble(entry: entry(node:))
+    end
+
+    # The tree whose first table is returned, so empty brackets, which select none of its columns, raise.
+    def root(node:)
+      root = build(node:)
+      raise ArgumentError, QueryCompiler.no_columns_message(table: root.source.table) if !root.join && root.source.no_columns?
+
+      root
+    end
+
+    # An expression's node, waiting for the children NestingPath nests in it.
+    def entry(node:)
       raise JoinError, QueryCompiler::INVERSION_JOIN_MESSAGE if node.is_a?(DataExpression::Inversion)
-      return build(node: node.node).with(keys: node.keys, rows: node.rows) if node.is_a?(DataExpression::Ordered)
-      return bracketed(source: node) if node.is_a?(DataExpression::Source)
+      return ordered(node:) if node.is_a?(DataExpression::Ordered)
+      return NestingPath::Entry.for(bracketed(source: node)) if node.is_a?(DataExpression::Source)
+      return NestingPath::Entry.for(Nesting::Node.new(source: NestedJoin.build(node:), key: nil, link: nil, children: [])) unless node.nest?
 
-      chain(operands: operands(node:).map { |operand| build(node: operand) })
+      @path.chain(segments: NestingPath.segments(node:))
     end
 
     # Returns the nested key and Link for a child table. On the "one" side a key matching a foreign key column picks it,
-    # so `author:` follows `author_id`. FilterCompiler links related tables the same way.
-    def link_to(parent:, child:, key:)
+    # so `author:` follows `author_id`, and a foreign key column named in round brackets picks between several.
+    # FilterCompiler links related tables the same way.
+    def link_to(parent:, child:, key:, named: {})
       to_one = @schema.links(from: parent, to: child)
-      named = named_link(links: to_one, key:)
-      return one(parent:, child:, link: named, key:) if named
+      named_link = named_link(links: to_one, key:)
+      return one(parent:, child:, link: named_link, key:) if named_link
 
-      links = to_one + @schema.links(from: child, to: parent)
+      links = picked(links: to_one + @schema.links(from: child, to: parent), named:)
       raise JoinError, "No foreign key links #{child} to #{parent}" if links.empty?
       raise JoinError, many_keys_message(parent:, child:, to_one:) if links.length > 1
-      return one(parent:, child:, link: links.first, key:) if to_one.any?
+      return one(parent:, child:, link: links.first, key:) if to_one.include?(links.first)
 
       many(parent:, child:, link: links.first, key:)
     end
 
     private
 
-    # A + chain is left deep, and each operand is a table, a bracketed table or a parenthesised + chain.
-    def operands(node:)
-      return [node] unless node.is_a?(DataExpression::Join)
-      raise JoinError, QueryCompiler::NESTING_JOIN_MESSAGE unless node.type == :nest
-
-      operands(node: node.left) + [node.right]
+    # A sort or limit applies to the first table of what it sorts.
+    def ordered(node:)
+      entry(node: node.node).tap { |entry| entry.node = entry.node.with(keys: node.keys, rows: node.rows) }
     end
 
-    # Tables in brackets nest directly under the table whose brackets they're in.
-    def bracketed(source:)
-      children = source.nested.map do |nested|
-        child = build(node: nested.node)
-        key, link = link_to(parent: source.table, child: child.source.table, key: nested.key)
-        child.with(key:, link:)
-      end
-
-      with_children(node: Nesting::Node.new(source:, key: nil, link: nil, children: []), children:)
+    # The links whose foreign key is named in round brackets, or all of them if none is.
+    def picked(links:, named:)
+      picked = links.select { |link| named.values.flatten.include?(link[:columns].first) }
+      picked.any? ? picked : links
     end
 
-    # Links the operands into a tree from the first. Every operand must be linked, and only by one path.
-    def chain(operands:)
-      check_duplicates!(operands:)
-
-      edges = operands.combination(2).select { |operand, other| linked?(operand.source.table, other.source.table) }
-      visited = [operands.first]
-      root = attach(operand: operands.first, node: operands.first, edges:, visited:)
-      check_chain!(operands:, visited:, edges:)
-
-      root
-    end
-
-    # Nests each unvisited operand linked to `operand`. `node` is the operand with its key and link set.
-    def attach(operand:, node:, edges:, visited:)
-      neighbours = edges.filter_map { |pair| (pair - [operand]).first if pair.include?(operand) } - visited
-      visited.concat(neighbours)
-
-      children = neighbours.map do |child|
-        key, link = link_to(parent: node.source.table, child: child.source.table, key: nil)
-        attach(operand: child, node: child.with(key:, link:), edges:, visited:)
-      end
-
-      with_children(node:, children:)
+    # Links each entry's children to it, from the leaves up.
+    def assemble(entry:)
+      children = entry.children.map { |child| linked(parent: entry.node, child: assemble(entry: child), key: nil) }
+      with_children(node: entry.node, children:)
     end
 
-    def with_children(node:, children:)
-      children = node.children + children
-      check_keys!(table: node.source.table, children:)
-      node.with(children:)
+    # Tables in brackets nest directly under the table whose brackets they're in.
+    def bracketed(source:)
+      node = Nesting::Node.new(source:, key: nil, link: nil, children: [])
+      with_children(node:, children: source.nested.map { |nested| linked(parent: node, child: build(node: nested.node), key: nested.key) })
     end
 
-    def check_duplicates!(operands:)
-      tables = operands.map { |operand| operand.source.table }
-      duplicate = tables.find { |table| tables.count(table) > 1 }
-      raise JoinError, "Can't join #{duplicate} to itself. Name each in brackets, e.g. author: Users[:username]" if duplicate
+    # Sets a child's key and link to its parent node. A join links through its table written next to the +.
+    def linked(parent:, child:, key:)
+      named = parent.foreign_keys.merge(child.foreign_keys)
+      table = parent.join&.linked_table(others: child.tables, schema: @schema, foreign_keys: named) || parent.source.table
+      joined = child.join&.link(parent: table, key:, tree: self, schema: @schema, foreign_keys: named)
+      source, key, link = joined || [child.source, *link_to(parent: table, child: child.source.table, key:, named:)]
+      child.with(source:, key:, link: link.with(parent_table: parent.join && table))
     end
 
-    def check_chain!(operands:, visited:, edges:)
-      tables = operands.map { |operand| operand.source.table }
-      unreached = (operands - visited).map { |operand| operand.source.table }
-      raise JoinError, "No foreign key links #{unreached.join(' and ')} to #{(tables - unreached).join(', ')}" if unreached.any?
-      raise JoinError, format(MULTIPLE_PATHS_MESSAGE, tables: tables.join(', ')) if edges.length > operands.length - 1
+    def with_children(node:, children:)
+      node.with(children: node.children + children).tap { |linked| check_keys!(node: linked) }
     end
 
-    def check_keys!(table:, children:)
-      keys = children.map(&:key)
+    # Each nested table needs its own key, which a renamed column can't also use.
+    def check_keys!(node:)
+      keys = node.children.map(&:key)
       duplicate = keys.find { |key| keys.count(key) > 1 }
-      raise JoinError, "Two tables nest in #{table} as #{duplicate}. Name them, e.g. author: Users[:username]" if duplicate
-    end
+      raise JoinError, "Two tables nest in #{node.tables.join(', ')} as #{duplicate}. Name them, e.g. author: Users[:username]" if duplicate
 
-    def linked?(table, other)
-      @schema.links(from: table, to: other).any? || @schema.links(from: other, to: table).any?
+      renamed = (keys & (node.join ? [] : node.source.renames.keys)).first
+      raise JoinError, "#{node.tables.join(', ')} returns #{renamed} as both a renamed column and a nested table. Rename one" if renamed
     end
 
     def named_link(links:, key:)

data/lib/order_compiler.rb

@@ -18,10 +18,12 @@ class LowData
       dataset.limit(rows.limit, rows.offset.zero? ? nil : rows.offset)
     end
 
+    # Rows without a value sort last in both directions, so `-Col[:views] * 10` is the 10 most viewed on every database.
+    # Postgres puts NULLs last ascending and first descending, and SQLite and MySQL the reverse.
     def order(keys:, tables:)
       keys.map do |key|
         column = Sequel[owner(column: key.column, tables:)][key.column]
-        key.descending ? column.desc : column
+        key.descending ? column.desc(nulls: :last) : column.asc(nulls: :last)
       end
     end
 

data/lib/query_compiler.rb

@@ -4,8 +4,10 @@ class LowData
   # Compiles a DataExpression join tree into a Sequel dataset, inferring each join's ON clause from foreign keys.
   class QueryCompiler
     INVERSION_JOIN_MESSAGE = "Table[] can't be joined with other expressions"
-    NESTING_JOIN_MESSAGE = 'Nested tables return nested data, so + and tables nested in brackets can\'t be combined with &, <, > or <=>'
-    ORDERED_JOIN_MESSAGE = 'Sort and limit after joining, e.g. (Users[] < Posts[]) ^ Col[:username]. Ruby binds ^ tighter ' \
+    NESTING_JOIN_MESSAGE = 'Nested tables return nested data, so + and tables nested in brackets can\'t be combined with &, <, > ' \
+                           'or <=>. Nest the join instead, e.g. Users[:username] + (Posts[:title] & Comments[:body])'
+    FULL_JOIN_MESSAGE = 'MySQL has no FULL JOIN, so <=> only runs on other databases. Use < or > for a left or right join'
+    ORDERED_JOIN_MESSAGE = 'Sort and limit after joining, e.g. (Users < Posts) ^ Col[:username]. Ruby binds ^ tighter ' \
                            'than <, > and <=>, and * and / tighter than every join, so add parentheses around the join'
 
     def initialize(database:)
@@ -17,26 +19,37 @@ class LowData
       @orders = OrderCompiler.new(schema: @schema)
     end
 
-    def compile(node:)
-      return compile_ordered(node:) if node.is_a?(DataExpression::Ordered)
+    # `links` are columns a nested join selects to link its rows, as well as the columns asked for. See Nesting.
+    def compile(node:, links: [])
+      return compile_ordered(node:, links:) if node.is_a?(DataExpression::Ordered)
 
-      compile_unordered(node:, sources: [])
+      compile_unordered(node:, sources: [], links:)
+    end
+
+    # Empty brackets select no columns, so a query of only those has nothing to return.
+    def self.no_columns_message(table:)
+      name = LowData.constant_name(table)
+      "Empty brackets select no columns, so #{name}[] returns nothing. Write #{name} for every column, or name them, " \
+        "e.g. #{name}[:id]"
     end
 
     private
 
     # Sort keys and rows apply to the whole query, so each sort column can belong to any joined table.
-    def compile_ordered(node:)
+    def compile_ordered(node:, links:)
       sources = []
-      dataset = compile_unordered(node: node.node, sources:)
+      dataset = compile_unordered(node: node.node, sources:, links:)
       @orders.apply(dataset:, keys: node.keys, rows: node.rows, tables: sources.map(&:table))
     end
 
-    def compile_unordered(node:, sources:)
+    def compile_unordered(node:, sources:, links:)
       return compile_inversion(node:, sources:) if node.is_a?(DataExpression::Inversion)
 
       dataset = filter(dataset: build(node:, sources:), sources:)
-      dataset.select(*sources.flat_map { |source| selections(source:) })
+      selections = sources.flat_map { |source| selections(source:) } + links
+      raise ArgumentError, QueryCompiler.no_columns_message(table: sources.first.table) if selections.empty?
+
+      dataset.select(*selections)
     end
 
     def compile_inversion(node:, sources:)
@@ -56,18 +69,22 @@ class LowData
     end
 
     def join_dataset(dataset:, type:, right:, sources:)
+      check_join!(type:, right:, sources:)
+      conditions = join_conditions(left: sources, right:)
+      sources << right
+      dataset.join_table(type, right.table, conditions)
+    end
+
+    def check_join!(type:, right:, sources:)
       raise JoinError, INVERSION_JOIN_MESSAGE if right.is_a?(DataExpression::Inversion)
       raise JoinError, ORDERED_JOIN_MESSAGE if right.is_a?(DataExpression::Ordered)
       raise JoinError, NESTING_JOIN_MESSAGE if right.nested.any?
       raise JoinError, "Can't join #{right.table} to itself" if sources.any? { |source| source.table == right.table }
-
-      conditions = join_conditions(left_tables: sources.map(&:table), right_table: right.table)
-      sources << right
-      dataset.join_table(type, right.table, conditions)
+      raise JoinError, FULL_JOIN_MESSAGE if type == :full && @database.database_type == :mysql
     end
 
     def nesting?(node:)
-      node.is_a?(DataExpression::Join) && node.type == :nest
+      node.is_a?(DataExpression::Join) && node.nest?
     end
 
     def source_dataset(source:, sources:)
@@ -82,26 +99,42 @@ class LowData
       sources.reduce(dataset) { |filtered, source| @filters.apply(dataset: filtered, source:) }
     end
 
+    # A bare table selects every column, and empty brackets select none.
     def selections(source:)
-      return [Sequel[source.table].*] if source.columns.empty?
+      return [Sequel[source.table].*] if source.every_column?
 
-      source.columns.map { |column| Sequel[source.table][column] }
+      @schema.check_renames!(table: source.table, renames: source.renames)
+      source.columns.map { |column| Sequel[source.table][column] } + source.aliases
     end
 
-    def join_conditions(left_tables:, right_table:)
-      candidates = left_tables.flat_map do |left_table|
-        @schema.references(from: right_table, to: left_table) + @schema.references(from: left_table, to: right_table)
-      end
-
-      raise JoinError, "No foreign key links #{right_table} to #{left_tables.join(', ')}" if candidates.empty?
-      raise JoinError, "More than one foreign key links #{right_table} to #{left_tables.join(', ')}" if candidates.length > 1
+    # Each table joins to the table before it, or to an earlier one by a foreign key named in round brackets, so foreign
+    # keys between other tables can't change or break a join.
+    def join_conditions(left:, right:)
+      named = left.flat_map { |source| references(from: right, to: source, named: true) + references(from: source, to: right, named: true) }
+      candidates = named.any? ? named : references(from: right, to: left.last) + references(from: left.last, to: right)
+      raise JoinError, unlinked_join_message(left:, right:) if candidates.empty?
+      raise JoinError, "More than one foreign key links #{right.table} to #{left.last.table}" if candidates.length > 1
 
       candidates.first
     end
 
+    def references(from:, to:, named: false)
+      @schema.references(from: from.table, to: to.table, named: named ? from.filter.foreign_keys : nil)
+    end
+
+    def unlinked_join_message(left:, right:)
+      message = "No foreign key links #{right.table} to #{left.last.table}, the table before it"
+      choices = left[0...-1].flat_map do |source|
+        [[right.table, source.table], [source.table, right.table]].flat_map do |from, to|
+          @schema.links(from:, to:).map { |link| "#{LowData.constant_name(from)}(:#{link[:columns].first})" }
+        end
+      end
+      choices.empty? ? message : "#{message}. To join it to an earlier table, name the foreign key: #{choices.sort.join(' or ')}"
+    end
+
     def nested_join_message
-      'Ruby evaluated a join on the right first, e.g. `Users[] < Posts[] & Comments[]` runs `Posts[] & Comments[]` first ' \
-        'because & binds tighter than <. Add parentheses to join from the left: `(Users[] < Posts[]) & Comments[]`'
+      'Ruby evaluated a join on the right first, e.g. `Users < Posts & Comments` runs `Posts & Comments` first ' \
+        'because & binds tighter than <. Add parentheses to join from the left: `(Users < Posts) & Comments`'
     end
   end
 end

data/lib/rows.rb

@@ -2,9 +2,9 @@
 
 class LowData
   # Which sorted rows to keep. Rows count from 0, as in Ruby:
-  #   Posts[] * 10                 # LIMIT 10
-  #   (Posts[] / 20)[2]            # LIMIT 20 OFFSET 40, the third page of 20
-  #   Posts[] ^ Col[:id][20...40]  # LIMIT 20 OFFSET 20
+  #   Posts * 10                   # LIMIT 10
+  #   (Posts / 20)[2]              # LIMIT 20 OFFSET 40, the third page of 20
+  #   Posts ^ Col[:id][20...40]    # LIMIT 20 OFFSET 20
   # Pages have a `page_size` until a page is picked, and a `limit` and `offset` after.
   Rows = ::Data.define(:offset, :limit, :page_size) do
     def self.limit(count)

data/lib/schema.rb

@@ -28,16 +28,33 @@ class LowData
         foreign_keys(table: other).any? { |foreign_key| foreign_key[:table] == table }
       end
 
-      (outgoing + incoming).uniq - [table]
+      # Sorted, because databases list their tables in different orders, and error messages name the first.
+      ((outgoing + incoming).uniq - [table]).sort
     end
 
-    # Foreign keys on the `from` table that reference the `to` table, as join conditions.
-    def references(from:, to:)
-      links(from:, to:).map do |link|
+    # Foreign keys on the `from` table that reference the `to` table, as join conditions. `named` keeps only the foreign
+    # keys with those columns.
+    def references(from:, to:, named: nil)
+      links(from:, to:).select { |link| named.nil? || (link[:columns] & named).any? }.map do |link|
         link[:columns].zip(link[:keys]).to_h { |column, key| [Sequel[from][column], Sequel[to][key]] }
       end
     end
 
+    # A renamed column must exist and its new name mustn't, so a rename written backwards, `title: :headline`, raises.
+    def check_renames!(table:, renames:)
+      columns = columns(table:)
+
+      renames.each do |name, column|
+        raise ArgumentError, backwards_rename_message(table:, name:, column:) if columns.include?(name) && !columns.include?(column)
+        raise ArgumentError, "#{table} has no #{column} column to rename" unless columns.include?(column)
+        raise ArgumentError, "#{table} already has a #{name} column, so #{column} can't be renamed to it" if columns.include?(name)
+      end
+    end
+
+    def linked?(table, other)
+      links(from: table, to: other).any? || links(from: other, to: table).any?
+    end
+
     # Foreign keys on the `from` table that reference the `to` table, as their columns and the keys they reference.
     def links(from:, to:)
       foreign_keys(table: from).select { |foreign_key| foreign_key[:table] == to }.map do |foreign_key|
@@ -47,6 +64,10 @@ class LowData
 
     private
 
+    def backwards_rename_message(table:, name:, column:)
+      "#{table} has no #{column} column. To rename #{name}, write #{column}: :#{name}"
+    end
+
     def schema(table:)
       @schemas[table] ||= @database.schema(table)
     end

data/lib/table_reference/writes.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class LowData
+  class TableReference
+    # Writes run straight away. See Writer:
+    #   Posts << { title: 'Hello' }                 # Inserts, returning the new row's primary key.
+    #   Posts(slug: 'hello') <= { title: 'Hello' }  # Upserts, matching on the round brackets.
+    #   Posts(id: 1)[:title] = 'New'                # Updates the rows chosen by the round brackets.
+    #   Posts(id: 1).delete                         # Deletes them, returning how many.
+    module Writes
+      def <<(rows)
+        writer.insert(source: write_source, rows:)
+      end
+
+      def <=(rows)
+        writer.upsert(source: write_source, rows:)
+      end
+
+      # Ruby makes an assignment return its right-hand side, so `Posts(id: 1)[:title] = 'New'` returns 'New'.
+      def []=(*columns, value)
+        writer.update(source: write_source, values: assignments(columns:, value:))
+      end
+
+      def delete
+        writer.delete(source: write_source)
+      end
+
+      private
+
+      def writer
+        Writer.new(database: LowData.database)
+      end
+
+      def write_source
+        raise ArgumentError, "~#{LowData.constant_name(table)} filters by related rows, so it can't be written to" if negated
+
+        source
+      end
+
+      # The columns in square brackets and the value assigned to them:
+      #   Posts(id: 1)[:title] = 'New'                  # One column takes a value.
+      #   Posts(id: 1)[:title, :body] = ['New', '...']  # Several columns take an array of as many values.
+      #   Posts(id: 1)[] = { title: 'New' }             # Empty brackets take a hash of columns and values.
+      def assignments(columns:, value:)
+        check_columns!(columns:)
+        return assigned_hash(value:) if columns.empty?
+        return { columns.first => assigned_value(value:) } if columns.one?
+        return columns.zip(value).to_h if value.is_a?(Array) && value.length == columns.length
+
+        raise ArgumentError, "#{columns.length} columns take #{columns.length} values, e.g. Posts(id: 1)[:title, :body] = ['New', '...']"
+      end
+
+      # Sequel would write a hash into one column as a condition, storing 0 or 1, so a hash for one column raises.
+      def assigned_value(value:)
+        return value unless value.is_a?(Hash)
+
+        raise ArgumentError, 'One column takes one value, not a hash. To set the columns in a hash, use empty brackets, e.g. ' \
+                             "Posts(id: 1)[] = { title: 'New' }"
+      end
+
+      def assigned_hash(value:)
+        return value if value.is_a?(Hash) && value.any?
+
+        raise ArgumentError, "Empty brackets take a hash of columns and values, e.g. Posts(id: 1)[] = { title: 'New' }"
+      end
+    end
+
+    include Writes
+  end
+end