skyward-orm 0.4.0 → 0.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/LICENSE +21 -0
- data/README.md +66 -48
- data/lib/skyward/orm/adapters/postgresql/connection.rb +64 -4
- data/lib/skyward/orm/adapters/postgresql.rb +95 -76
- data/lib/skyward/orm/adapters/sqlite/connection.rb +87 -0
- data/lib/skyward/orm/adapters/sqlite/constraints.rb +15 -15
- data/lib/skyward/orm/adapters/sqlite.rb +59 -55
- data/lib/skyward/orm/adapters/statement_cache.rb +51 -0
- data/lib/skyward/orm/adapters.rb +12 -6
- data/lib/skyward/orm/cli/boot_file.rb +2 -2
- data/lib/skyward/orm/cli/migration.rb +7 -7
- data/lib/skyward/orm/cli/scaffold/source.rb +49 -30
- data/lib/skyward/orm/cli/scaffold.rb +6 -6
- data/lib/skyward/orm/commands.rb +9 -9
- data/lib/skyward/orm/connection/instrumented.rb +4 -2
- data/lib/skyward/orm/connection/pool.rb +2 -2
- data/lib/skyward/orm/database/decoders.rb +41 -0
- data/lib/skyward/orm/database/schema_check.rb +3 -3
- data/lib/skyward/orm/database.rb +65 -31
- data/lib/skyward/orm/migrations/definitions.rb +13 -13
- data/lib/skyward/orm/migrations/diff.rb +4 -4
- data/lib/skyward/orm/migrations/directory.rb +5 -5
- data/lib/skyward/orm/migrations/runner.rb +8 -8
- data/lib/skyward/orm/migrations/script.rb +9 -9
- data/lib/skyward/orm/migrations/status.rb +7 -7
- data/lib/skyward/orm/migrations/summary.rb +22 -22
- data/lib/skyward/orm/migrations/versions.rb +2 -3
- data/lib/skyward/orm/projection.rb +6 -12
- data/lib/skyward/orm/queries/clauses.rb +201 -112
- data/lib/skyward/orm/query.rb +2 -2
- data/lib/skyward/orm/record.rb +5 -9
- data/lib/skyward/orm/statements/placeholders.rb +3 -3
- data/lib/skyward/orm/statements.rb +34 -28
- data/lib/skyward/orm/tables/column_types.rb +7 -7
- data/lib/skyward/orm/tables/declarations.rb +5 -5
- data/lib/skyward/orm/tables/rows.rb +28 -10
- data/lib/skyward/orm/tables/sources.rb +3 -3
- data/lib/skyward/orm/tables/values.rb +18 -18
- data/lib/skyward/orm/version.rb +1 -1
- data/lib/skyward/orm.rb +15 -14
- data/sig/generated/skyward/orm/adapters/postgresql/connection.rbs +35 -3
- data/sig/generated/skyward/orm/adapters/postgresql.rbs +14 -3
- data/sig/generated/skyward/orm/adapters/sqlite/connection.rbs +55 -0
- data/sig/generated/skyward/orm/adapters/sqlite.rbs +11 -6
- data/sig/generated/skyward/orm/adapters/statement_cache.rbs +37 -0
- data/sig/generated/skyward/orm/adapters.rbs +3 -0
- data/sig/generated/skyward/orm/cli/scaffold/source.rbs +11 -0
- data/sig/generated/skyward/orm/connection/instrumented.rbs +4 -2
- data/sig/generated/skyward/orm/database/decoders.rbs +19 -0
- data/sig/generated/skyward/orm/database.rbs +38 -14
- data/sig/generated/skyward/orm/queries/clauses.rbs +81 -28
- data/sig/generated/skyward/orm/record.rbs +6 -7
- data/sig/generated/skyward/orm/statements.rbs +8 -10
- data/sig/generated/skyward/orm/tables/rows.rbs +1 -1
- data/sig/generated/skyward/orm.rbs +2 -2
- data/sig/manual/pg.rbs +10 -0
- data/sig/manual/skyward/orm/database/decoders.rbs +3 -0
- data/sig/manual/skyward/orm.rbs +9 -3
- data/sig/manual/sqlite3.rbs +13 -2
- metadata +11 -3
|
@@ -45,6 +45,11 @@ module Skyward::ORM::Queries::Clauses
|
|
|
45
45
|
:on #: Hash[Symbol, Symbol]
|
|
46
46
|
)
|
|
47
47
|
|
|
48
|
+
InList = Data.define(
|
|
49
|
+
:placeholders, #: Integer
|
|
50
|
+
:null #: bool
|
|
51
|
+
)
|
|
52
|
+
|
|
48
53
|
# @rbs @table: singleton(Skyward::ORM::Record)
|
|
49
54
|
# @rbs @session: Skyward::ORM::Connection::Session
|
|
50
55
|
# @rbs @joins: Array[Join]
|
|
@@ -102,12 +107,12 @@ module Skyward::ORM::Queries::Clauses
|
|
|
102
107
|
# @rbs table: singleton(Skyward::ORM::Record)
|
|
103
108
|
# @rbs **on: Symbol
|
|
104
109
|
# @rbs return: self
|
|
105
|
-
def join(table, **on) = with(joins: [*@joins, joined(
|
|
110
|
+
def join(table, **on) = with(joins: [*@joins, joined('JOIN', table, on)])
|
|
106
111
|
|
|
107
112
|
# @rbs table: singleton(Skyward::ORM::Record)
|
|
108
113
|
# @rbs **on: Symbol
|
|
109
114
|
# @rbs return: self
|
|
110
|
-
def left_join(table, **on) = with(joins: [*@joins, joined(
|
|
115
|
+
def left_join(table, **on) = with(joins: [*@joins, joined('LEFT JOIN', table, on)])
|
|
111
116
|
|
|
112
117
|
# @rbs sql: String?
|
|
113
118
|
# @rbs *values: untyped
|
|
@@ -216,10 +221,12 @@ module Skyward::ORM::Queries::Clauses
|
|
|
216
221
|
|
|
217
222
|
database = @session.database
|
|
218
223
|
prepare(database)
|
|
219
|
-
sql, binds =
|
|
220
|
-
|
|
224
|
+
sql, binds = selecting(database, :count, [], @limit) do |from|
|
|
225
|
+
counted = @groups.empty? && @limit.nil? && @offset.nil? ? from : %(FROM (SELECT 1 #{from}) AS "counted")
|
|
226
|
+
"SELECT COUNT(*) #{counted}"
|
|
227
|
+
end
|
|
221
228
|
# PostgreSQL's driver returns every value as text, so the adapter reads it.
|
|
222
|
-
database.adapter.decode(COUNT, database.execute(
|
|
229
|
+
database.adapter.decode(COUNT, database.execute(sql, binds).fetch(0).fetch(0))
|
|
223
230
|
end
|
|
224
231
|
|
|
225
232
|
# Order can't change whether the query has a row, so it's left out, and a
|
|
@@ -228,8 +235,8 @@ module Skyward::ORM::Queries::Clauses
|
|
|
228
235
|
def exists?
|
|
229
236
|
database = @session.database
|
|
230
237
|
prepare(database)
|
|
231
|
-
sql, binds =
|
|
232
|
-
!database.execute(
|
|
238
|
+
sql, binds = selecting(database, :exists, [], [@limit, 1].compact.min) { |from| "SELECT 1 #{from}" }
|
|
239
|
+
!database.execute(sql, binds).empty?
|
|
233
240
|
end
|
|
234
241
|
|
|
235
242
|
# @rbs () { (R) -> void } -> self
|
|
@@ -307,7 +314,7 @@ module Skyward::ORM::Queries::Clauses
|
|
|
307
314
|
if other.is_a?(Skyward::ORM::Projection)
|
|
308
315
|
raise ArgumentError,
|
|
309
316
|
"#{@table} can't merge a projection, whose row class and expressions would have nowhere to go. " \
|
|
310
|
-
|
|
317
|
+
'Merge the query before its into.'
|
|
311
318
|
end
|
|
312
319
|
return if other.is_a?(Skyward::ORM::Query)
|
|
313
320
|
|
|
@@ -353,11 +360,11 @@ module Skyward::ORM::Queries::Clauses
|
|
|
353
360
|
# @rbs value: untyped
|
|
354
361
|
# @rbs return: Array[Comparison]
|
|
355
362
|
def comparisons(column, value)
|
|
356
|
-
return [Comparison.new(column:, operator:
|
|
363
|
+
return [Comparison.new(column:, operator: '=', value:)] unless value.is_a?(Range)
|
|
357
364
|
|
|
358
365
|
ends = [
|
|
359
|
-
(Comparison.new(column:, operator:
|
|
360
|
-
(Comparison.new(column:, operator: value.exclude_end? ?
|
|
366
|
+
(Comparison.new(column:, operator: '>=', value: value.begin) unless value.begin.nil?),
|
|
367
|
+
(Comparison.new(column:, operator: value.exclude_end? ? '<' : '<=', value: value.end) unless value.end.nil?)
|
|
361
368
|
].compact
|
|
362
369
|
raise ArgumentError, "#{@table} can't match #{column} to #{value.inspect}, a range with neither end" if ends.empty?
|
|
363
370
|
|
|
@@ -367,12 +374,12 @@ module Skyward::ORM::Queries::Clauses
|
|
|
367
374
|
# @rbs return: Array[String]
|
|
368
375
|
def clauses
|
|
369
376
|
[
|
|
370
|
-
(
|
|
371
|
-
(
|
|
372
|
-
(
|
|
373
|
-
(
|
|
374
|
-
(
|
|
375
|
-
(
|
|
377
|
+
('into expressions' unless @expressions.empty?),
|
|
378
|
+
('join' unless @joins.empty?),
|
|
379
|
+
('order' unless @orders.empty?),
|
|
380
|
+
('group' unless @groups.empty?),
|
|
381
|
+
('limit' if @limit),
|
|
382
|
+
('offset' if @offset)
|
|
376
383
|
].compact
|
|
377
384
|
end
|
|
378
385
|
|
|
@@ -380,7 +387,7 @@ module Skyward::ORM::Queries::Clauses
|
|
|
380
387
|
# @rbs return: String
|
|
381
388
|
def listing(clauses)
|
|
382
389
|
*others, last = clauses
|
|
383
|
-
others.empty? ? last.to_s : "#{others.join(
|
|
390
|
+
others.empty? ? last.to_s : "#{others.join(', ')} or #{last}"
|
|
384
391
|
end
|
|
385
392
|
|
|
386
393
|
# Neither PostgreSQL nor SQLite (as it's usually built) takes a JOIN,
|
|
@@ -416,12 +423,12 @@ module Skyward::ORM::Queries::Clauses
|
|
|
416
423
|
def require_members(row, expressions)
|
|
417
424
|
members = Skyward::ORM::Tables::Members.of(row)
|
|
418
425
|
unknown = expressions.keys - members
|
|
419
|
-
raise ArgumentError, "#{row} has no member #{unknown.join(
|
|
426
|
+
raise ArgumentError, "#{row} has no member #{unknown.join(', ')} to take an expression" unless unknown.empty?
|
|
420
427
|
|
|
421
428
|
unread = members - @table.schema.columns - expressions.keys
|
|
422
429
|
return if unread.empty?
|
|
423
430
|
|
|
424
|
-
raise ArgumentError, "#{@table} has no column #{unread.join(
|
|
431
|
+
raise ArgumentError, "#{@table} has no column #{unread.join(', ')}, so #{row} needs an expression for it"
|
|
425
432
|
end
|
|
426
433
|
|
|
427
434
|
# @rbs database: Skyward::ORM::Database
|
|
@@ -429,21 +436,95 @@ module Skyward::ORM::Queries::Clauses
|
|
|
429
436
|
# @rbs limit: Integer?
|
|
430
437
|
# @rbs return: [String, Array[untyped]]
|
|
431
438
|
def statement(database, orders, limit)
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
439
|
+
selecting(database, [:select, @row, @expressions], orders, limit) do |from|
|
|
440
|
+
columns = Skyward::ORM::Tables::Members.of(@row).map do |member|
|
|
441
|
+
expression = @expressions.fetch(member, nil)
|
|
442
|
+
expression ? "#{expression} AS #{Skyward::ORM::Statements.quote(member)}" : qualified(member)
|
|
443
|
+
end.join(', ')
|
|
444
|
+
"SELECT #{columns} #{from}"
|
|
445
|
+
end
|
|
438
446
|
end
|
|
439
447
|
|
|
448
|
+
# The SQL is rendered from the conditions' shapes, not the conditions, so
|
|
449
|
+
# two queries that share a key can't render different SQL.
|
|
440
450
|
# @rbs database: Skyward::ORM::Database
|
|
451
|
+
# @rbs kind: Symbol | Array[untyped]
|
|
441
452
|
# @rbs orders: Array[[Symbol, direction]]
|
|
442
453
|
# @rbs limit: Integer?
|
|
454
|
+
# @rbs &: (String from) -> String
|
|
443
455
|
# @rbs return: [String, Array[untyped]]
|
|
444
|
-
def
|
|
456
|
+
def selecting(database, kind, orders, limit)
|
|
457
|
+
shapes, binds = bound(database)
|
|
458
|
+
# A Hash's == ignores the order of its pairs, but ON joins them in it.
|
|
459
|
+
joins = @joins.map { |join| [join.keyword, join.table, join.on.to_a] }
|
|
460
|
+
key = [kind, @table, joins, orders, @groups, limit.nil?, @offset.nil?, shapes]
|
|
461
|
+
sql = database.cached_sql(key) { yield from(database, shapes, orders, limit) }
|
|
462
|
+
[sql, [*binds, *[limit, @offset].compact]]
|
|
463
|
+
end
|
|
464
|
+
|
|
465
|
+
# The binds follow the order in which from numbers their placeholders.
|
|
466
|
+
# @rbs database: Skyward::ORM::Database
|
|
467
|
+
# @rbs return: [Array[condition], Array[untyped]]
|
|
468
|
+
def bound(database)
|
|
469
|
+
shaped(database.adapter, Skyward::ORM::Statements.by_name(database.column_types, @table), @conditions)
|
|
470
|
+
end
|
|
471
|
+
|
|
472
|
+
# @rbs adapter: Skyward::ORM::_Adapter
|
|
473
|
+
# @rbs columns: Hash[Symbol, Skyward::ORM::Tables::Column]
|
|
474
|
+
# @rbs conditions: Array[condition]
|
|
475
|
+
# @rbs return: [Array[condition], Array[untyped]]
|
|
476
|
+
def shaped(adapter, columns, conditions)
|
|
477
|
+
pairs = conditions.map { |condition| shape(adapter, columns, condition) }
|
|
478
|
+
[pairs.map { |shape, _| shape }, pairs.flat_map { |_, binds| binds }]
|
|
479
|
+
end
|
|
480
|
+
|
|
481
|
+
# @rbs adapter: Skyward::ORM::_Adapter
|
|
482
|
+
# @rbs columns: Hash[Symbol, Skyward::ORM::Tables::Column]
|
|
483
|
+
# @rbs condition: condition
|
|
484
|
+
# @rbs return: [condition, Array[untyped]]
|
|
485
|
+
def shape(adapter, columns, condition)
|
|
486
|
+
case condition
|
|
487
|
+
when Comparison then compared(adapter, columns.fetch(condition.column), condition)
|
|
488
|
+
when Fragment
|
|
489
|
+
binds = condition.values.map { |value| adapter.encode(value) }
|
|
490
|
+
Skyward::ORM::Statements::Placeholders.require_scalars(binds, 'An SQL condition')
|
|
491
|
+
[condition.with(values: binds.map { :bound }), binds]
|
|
492
|
+
when Negation
|
|
493
|
+
shapes, binds = shaped(adapter, columns, condition.conditions)
|
|
494
|
+
[Negation.new(conditions: shapes), binds]
|
|
495
|
+
when Disjunction
|
|
496
|
+
left, left_binds = shaped(adapter, columns, condition.left)
|
|
497
|
+
right, right_binds = shaped(adapter, columns, condition.right)
|
|
498
|
+
[Disjunction.new(left:, right:), [*left_binds, *right_binds]]
|
|
499
|
+
end
|
|
500
|
+
end
|
|
501
|
+
|
|
502
|
+
# @rbs adapter: Skyward::ORM::_Adapter
|
|
503
|
+
# @rbs column: Skyward::ORM::Tables::Column
|
|
504
|
+
# @rbs comparison: Comparison
|
|
505
|
+
# @rbs return: [Comparison, Array[untyped]]
|
|
506
|
+
def compared(adapter, column, comparison)
|
|
507
|
+
value = comparison.value
|
|
508
|
+
case value
|
|
509
|
+
when nil then [comparison, []]
|
|
510
|
+
when Array
|
|
511
|
+
present = value.compact
|
|
512
|
+
[
|
|
513
|
+
comparison.with(value: InList.new(placeholders: present.size, null: value.include?(nil))),
|
|
514
|
+
present.map { |item| Skyward::ORM::Statements.encode(adapter, column, item) }
|
|
515
|
+
]
|
|
516
|
+
else [comparison.with(value: :bound), [Skyward::ORM::Statements.encode(adapter, column, value)]]
|
|
517
|
+
end
|
|
518
|
+
end
|
|
519
|
+
|
|
520
|
+
# @rbs database: Skyward::ORM::Database
|
|
521
|
+
# @rbs shapes: Array[condition]
|
|
522
|
+
# @rbs orders: Array[[Symbol, direction]]
|
|
523
|
+
# @rbs limit: Integer?
|
|
524
|
+
# @rbs return: String
|
|
525
|
+
def from(database, shapes, orders, limit)
|
|
445
526
|
adapter = database.adapter
|
|
446
|
-
where,
|
|
527
|
+
where, count = filter(database, shapes, 1)
|
|
447
528
|
columns = Skyward::ORM::Statements.by_name(database.column_types, @table)
|
|
448
529
|
ordered = orders.map do |column, direction|
|
|
449
530
|
"#{adapter.comparable(columns[column]&.type || :untyped, qualified(column))} #{direction.upcase}"
|
|
@@ -451,148 +532,143 @@ module Skyward::ORM::Queries::Clauses
|
|
|
451
532
|
# The limit and offset are bound rather than written in, so every page of a
|
|
452
533
|
# query shares one SQL string.
|
|
453
534
|
paging = [limit, @offset].compact
|
|
454
|
-
|
|
535
|
+
[
|
|
455
536
|
"FROM #{Skyward::ORM::Statements.quote(@table.table_name)}",
|
|
456
537
|
*@joins.map { |join| joining(join) },
|
|
457
538
|
where,
|
|
458
|
-
("GROUP BY #{@groups.map { |column| qualified(column) }.join(
|
|
459
|
-
("ORDER BY #{ordered.join(
|
|
460
|
-
limit ? "LIMIT #{adapter.placeholder(
|
|
461
|
-
("OFFSET #{adapter.placeholder(
|
|
462
|
-
].compact.join(
|
|
463
|
-
[sql, [*binds, *paging]]
|
|
539
|
+
("GROUP BY #{@groups.map { |column| qualified(column) }.join(', ')}" unless @groups.empty?),
|
|
540
|
+
("ORDER BY #{ordered.join(', ')}" unless orders.empty?),
|
|
541
|
+
limit ? "LIMIT #{adapter.placeholder(count + 1)}" : (adapter.unlimited if @offset),
|
|
542
|
+
("OFFSET #{adapter.placeholder(count + paging.size)}" if @offset)
|
|
543
|
+
].compact.join(' ')
|
|
464
544
|
end
|
|
465
545
|
|
|
466
546
|
# @rbs join: Join
|
|
467
547
|
# @rbs return: String
|
|
468
548
|
def joining(join)
|
|
469
|
-
on = join.on.map { |column, joined| "#{qualified(column)} = #{qualified(joined, join.table)}" }.join(
|
|
549
|
+
on = join.on.map { |column, joined| "#{qualified(column)} = #{qualified(joined, join.table)}" }.join(' AND ')
|
|
470
550
|
"#{join.keyword} #{Skyward::ORM::Statements.quote(join.table.table_name)} ON #{on}"
|
|
471
551
|
end
|
|
472
552
|
|
|
473
553
|
# An UPDATE binds its SET values first, so its WHERE's numbered placeholders
|
|
474
554
|
# start after them.
|
|
475
555
|
# @rbs database: Skyward::ORM::Database
|
|
556
|
+
# @rbs shapes: Array[condition]
|
|
476
557
|
# @rbs position: Integer
|
|
477
|
-
# @rbs return: [String?,
|
|
478
|
-
def filter(database, position)
|
|
479
|
-
clauses,
|
|
480
|
-
[("WHERE #{clauses}" unless
|
|
558
|
+
# @rbs return: [String?, Integer]
|
|
559
|
+
def filter(database, shapes, position)
|
|
560
|
+
clauses, count = conjunction(database, shapes, position)
|
|
561
|
+
[("WHERE #{clauses}" unless shapes.empty?), count]
|
|
481
562
|
end
|
|
482
563
|
|
|
483
564
|
# @rbs database: Skyward::ORM::Database
|
|
484
|
-
# @rbs
|
|
565
|
+
# @rbs shapes: Array[condition]
|
|
485
566
|
# @rbs position: Integer
|
|
486
|
-
# @rbs return: [String,
|
|
487
|
-
def conjunction(database,
|
|
488
|
-
none = [[],
|
|
489
|
-
clauses,
|
|
490
|
-
sql,
|
|
491
|
-
[[*sqls,
|
|
567
|
+
# @rbs return: [String, Integer]
|
|
568
|
+
def conjunction(database, shapes, position)
|
|
569
|
+
none = [[], 0] #: [Array[String], Integer]
|
|
570
|
+
clauses, count = shapes.reduce(none) do |(sqls, taken), shape|
|
|
571
|
+
sql, placeholders = render(database, shape, position + taken)
|
|
572
|
+
[[*sqls, shape.is_a?(Disjunction) && shapes.size > 1 ? "(#{sql})" : sql], taken + placeholders]
|
|
492
573
|
end
|
|
493
|
-
[clauses.join(
|
|
574
|
+
[clauses.join(' AND '), count]
|
|
494
575
|
end
|
|
495
576
|
|
|
496
577
|
# @rbs database: Skyward::ORM::Database
|
|
497
|
-
# @rbs
|
|
578
|
+
# @rbs shape: condition
|
|
498
579
|
# @rbs position: Integer
|
|
499
|
-
# @rbs return: [String,
|
|
500
|
-
def render(database,
|
|
501
|
-
case
|
|
502
|
-
when Comparison then comparison(database,
|
|
503
|
-
when Fragment then fragment(database,
|
|
504
|
-
when Negation then negation(database,
|
|
580
|
+
# @rbs return: [String, Integer]
|
|
581
|
+
def render(database, shape, position)
|
|
582
|
+
case shape
|
|
583
|
+
when Comparison then comparison(database, shape, position)
|
|
584
|
+
when Fragment then fragment(database.adapter, shape, position)
|
|
585
|
+
when Negation then negation(database, shape.conditions, position)
|
|
505
586
|
when Disjunction
|
|
506
|
-
left,
|
|
507
|
-
right,
|
|
508
|
-
["#{left} OR #{right}",
|
|
587
|
+
left, left_count = alternative(database, shape.left, position)
|
|
588
|
+
right, right_count = alternative(database, shape.right, position + left_count)
|
|
589
|
+
["#{left} OR #{right}", left_count + right_count]
|
|
509
590
|
end
|
|
510
591
|
end
|
|
511
592
|
|
|
512
593
|
# @rbs database: Skyward::ORM::Database
|
|
513
594
|
# @rbs comparison: Comparison
|
|
514
595
|
# @rbs position: Integer
|
|
515
|
-
# @rbs return: [String,
|
|
596
|
+
# @rbs return: [String, Integer]
|
|
516
597
|
def comparison(database, comparison, position)
|
|
517
598
|
adapter = database.adapter
|
|
518
|
-
column = Skyward::ORM::Statements.by_name(database.column_types, @table).fetch(comparison.column)
|
|
519
599
|
name = qualified(comparison.column)
|
|
520
600
|
value = comparison.value
|
|
521
601
|
case value
|
|
522
|
-
when nil then ["#{name} IS NULL",
|
|
523
|
-
when
|
|
602
|
+
when nil then ["#{name} IS NULL", 0]
|
|
603
|
+
when InList then within(adapter, name, value, position)
|
|
524
604
|
else
|
|
605
|
+
column = Skyward::ORM::Statements.by_name(database.column_types, @table).fetch(comparison.column)
|
|
525
606
|
# = compares exactly as the column stores its values, and only a range's
|
|
526
607
|
# ends need them in order.
|
|
527
|
-
compared = comparison.operator ==
|
|
528
|
-
|
|
529
|
-
["#{compared} #{comparison.operator} #{adapter.placeholder(position)}", [bound]]
|
|
608
|
+
compared = comparison.operator == '=' ? name : adapter.comparable(column.type, name)
|
|
609
|
+
["#{compared} #{comparison.operator} #{adapter.placeholder(position)}", 1]
|
|
530
610
|
end
|
|
531
611
|
end
|
|
532
612
|
|
|
533
|
-
# @rbs
|
|
613
|
+
# @rbs adapter: Skyward::ORM::_Adapter
|
|
534
614
|
# @rbs fragment: Fragment
|
|
535
615
|
# @rbs position: Integer
|
|
536
|
-
# @rbs return: [String,
|
|
537
|
-
def fragment(
|
|
538
|
-
|
|
539
|
-
|
|
540
|
-
Skyward::ORM::Statements::Placeholders.require_scalars(binds, "An SQL condition")
|
|
541
|
-
sql = Skyward::ORM::Statements::Placeholders.replace(fragment.sql, binds.size) do |index|
|
|
616
|
+
# @rbs return: [String, Integer]
|
|
617
|
+
def fragment(adapter, fragment, position)
|
|
618
|
+
count = fragment.values.size
|
|
619
|
+
sql = Skyward::ORM::Statements::Placeholders.replace(fragment.sql, count) do |index|
|
|
542
620
|
adapter.placeholder(position + index - 1)
|
|
543
621
|
end
|
|
544
622
|
# A -- comment runs to the end of its line, so the closing parenthesis
|
|
545
623
|
# goes on a line of its own.
|
|
546
|
-
["(#{sql}#{"\n" if sql.include?(
|
|
624
|
+
["(#{sql}#{"\n" if sql.include?('--')})", count]
|
|
547
625
|
end
|
|
548
626
|
|
|
549
627
|
# NOT of an unknown is unknown, so a row whose column is NULL would be left
|
|
550
628
|
# out, though it doesn't match. An untyped column may hold NULL, and an SQL
|
|
551
629
|
# string's columns can't be known.
|
|
552
630
|
# @rbs database: Skyward::ORM::Database
|
|
553
|
-
# @rbs
|
|
631
|
+
# @rbs shapes: Array[condition]
|
|
554
632
|
# @rbs position: Integer
|
|
555
|
-
# @rbs return: [String,
|
|
556
|
-
def negation(database,
|
|
557
|
-
sql,
|
|
633
|
+
# @rbs return: [String, Integer]
|
|
634
|
+
def negation(database, shapes, position)
|
|
635
|
+
sql, count = conjunction(database, shapes, position)
|
|
558
636
|
nullable = database.column_types.columns(@table).select { |column| column.nullable || column.type == :untyped }
|
|
559
637
|
.map(&:name)
|
|
560
|
-
unknowable =
|
|
561
|
-
next unless
|
|
638
|
+
unknowable = shapes.filter_map do |shape|
|
|
639
|
+
next unless shape.is_a?(Comparison) && nullable.include?(shape.column)
|
|
562
640
|
|
|
563
|
-
value =
|
|
564
|
-
|
|
641
|
+
value = shape.value
|
|
642
|
+
shape.column unless value.nil? || (value.is_a?(InList) && value.null)
|
|
565
643
|
end
|
|
566
644
|
kept = unknowable.uniq.map { |column| " OR #{qualified(column)} IS NULL" }.join
|
|
567
|
-
[kept.empty? ? "NOT (#{sql})" : "(NOT (#{sql})#{kept})",
|
|
645
|
+
[kept.empty? ? "NOT (#{sql})" : "(NOT (#{sql})#{kept})", count]
|
|
568
646
|
end
|
|
569
647
|
|
|
570
648
|
# @rbs database: Skyward::ORM::Database
|
|
571
|
-
# @rbs
|
|
649
|
+
# @rbs shapes: Array[condition]
|
|
572
650
|
# @rbs position: Integer
|
|
573
|
-
# @rbs return: [String,
|
|
574
|
-
def alternative(database,
|
|
575
|
-
sql,
|
|
576
|
-
[
|
|
651
|
+
# @rbs return: [String, Integer]
|
|
652
|
+
def alternative(database, shapes, position)
|
|
653
|
+
sql, count = conjunction(database, shapes, position)
|
|
654
|
+
[shapes.size > 1 ? "(#{sql})" : sql, count]
|
|
577
655
|
end
|
|
578
656
|
|
|
579
657
|
# PostgreSQL refuses an empty IN (), and IN never matches NULL.
|
|
580
658
|
# @rbs adapter: Skyward::ORM::_Adapter
|
|
581
|
-
# @rbs column: Skyward::ORM::Tables::Column
|
|
582
659
|
# @rbs name: String
|
|
583
|
-
# @rbs
|
|
660
|
+
# @rbs list: InList
|
|
584
661
|
# @rbs position: Integer
|
|
585
|
-
# @rbs return: [String,
|
|
586
|
-
def within(adapter,
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
elsif
|
|
592
|
-
|
|
593
|
-
else list
|
|
662
|
+
# @rbs return: [String, Integer]
|
|
663
|
+
def within(adapter, name, list, position)
|
|
664
|
+
placeholders = Array.new(list.placeholders) { |index| adapter.placeholder(position + index) }
|
|
665
|
+
listed = "#{name} IN (#{placeholders.join(', ')})"
|
|
666
|
+
sql = if list.placeholders.zero? && !list.null then '1 = 0'
|
|
667
|
+
elsif list.placeholders.zero? then "#{name} IS NULL"
|
|
668
|
+
elsif list.null then "(#{listed} OR #{name} IS NULL)"
|
|
669
|
+
else listed
|
|
594
670
|
end
|
|
595
|
-
[sql,
|
|
671
|
+
[sql, list.placeholders]
|
|
596
672
|
end
|
|
597
673
|
|
|
598
674
|
# Steep can't tie the row class to R, so the rows are untyped here and each
|
|
@@ -633,34 +709,47 @@ module Skyward::ORM::Queries::Clauses
|
|
|
633
709
|
end
|
|
634
710
|
|
|
635
711
|
# @rbs values: Hash[Symbol, untyped]
|
|
712
|
+
# @rbs returned_row: Class?
|
|
636
713
|
# @rbs return: [String, Array[untyped]]
|
|
637
|
-
def updating(values)
|
|
714
|
+
def updating(values, returned_row)
|
|
638
715
|
raise ArgumentError, "#{@table} update needs a column to set, such as update(done: true)" if values.empty?
|
|
639
716
|
|
|
640
717
|
database = @session.database
|
|
641
718
|
column_types = database.column_types
|
|
642
719
|
Skyward::ORM::Statements.require_values(column_types, database.tables, @table, values)
|
|
643
|
-
|
|
644
|
-
|
|
720
|
+
columns = values.keys
|
|
721
|
+
set = Skyward::ORM::Statements.binds(database.adapter, column_types, @table, values)
|
|
722
|
+
changing(:update, columns, set, returned_row) do
|
|
723
|
+
assignments = columns.each.with_index(1).map do |column, position|
|
|
724
|
+
"#{Skyward::ORM::Statements.quote(column)} = #{database.adapter.placeholder(position)}"
|
|
725
|
+
end
|
|
726
|
+
"UPDATE #{Skyward::ORM::Statements.quote(@table.table_name)} SET #{assignments.join(', ')}"
|
|
645
727
|
end
|
|
646
|
-
changing(
|
|
647
|
-
:update,
|
|
648
|
-
"UPDATE #{Skyward::ORM::Statements.quote(@table.table_name)} SET #{assignments.join(", ")}",
|
|
649
|
-
Skyward::ORM::Statements.binds(database.adapter, column_types, @table, values)
|
|
650
|
-
)
|
|
651
728
|
end
|
|
652
729
|
|
|
730
|
+
# @rbs returned_row: Class?
|
|
653
731
|
# @rbs return: [String, Array[untyped]]
|
|
654
|
-
def deleting
|
|
732
|
+
def deleting(returned_row)
|
|
733
|
+
changing(:delete, [], [], returned_row) { "DELETE FROM #{Skyward::ORM::Statements.quote(@table.table_name)}" }
|
|
734
|
+
end
|
|
655
735
|
|
|
736
|
+
# require_writable leaves a write no clause but its conditions, so they and
|
|
737
|
+
# what it sets and returns are its shape.
|
|
656
738
|
# @rbs method: Symbol
|
|
657
|
-
# @rbs
|
|
739
|
+
# @rbs columns: Array[Symbol]
|
|
658
740
|
# @rbs set: Array[untyped]
|
|
741
|
+
# @rbs returned_row: Class?
|
|
742
|
+
# @rbs &: () -> String
|
|
659
743
|
# @rbs return: [String, Array[untyped]]
|
|
660
|
-
def changing(method,
|
|
744
|
+
def changing(method, columns, set, returned_row)
|
|
661
745
|
require_writable(method)
|
|
662
|
-
|
|
663
|
-
|
|
746
|
+
database = @session.database
|
|
747
|
+
shapes, binds = bound(database)
|
|
748
|
+
sql = database.cached_sql([method, @table, columns, returned_row, shapes]) do
|
|
749
|
+
where, = filter(database, shapes, set.size + 1)
|
|
750
|
+
[yield, where, (Skyward::ORM::Statements.returning(returned_row) if returned_row)].compact.join(' ')
|
|
751
|
+
end
|
|
752
|
+
[sql, [*set, *binds]]
|
|
664
753
|
end
|
|
665
754
|
|
|
666
755
|
# @rbs [T] (T | Skyward::ORM::Violation written) -> T
|
data/lib/skyward/orm/query.rb
CHANGED
|
@@ -7,7 +7,7 @@ class Skyward::ORM::Query
|
|
|
7
7
|
# @rbs **values: untyped
|
|
8
8
|
# @rbs return: Integer | Skyward::ORM::Violation
|
|
9
9
|
def update(**values)
|
|
10
|
-
sql, binds = updating(values)
|
|
10
|
+
sql, binds = updating(values, nil)
|
|
11
11
|
@session.database.write(@table, sql, binds)
|
|
12
12
|
end
|
|
13
13
|
|
|
@@ -17,7 +17,7 @@ class Skyward::ORM::Query
|
|
|
17
17
|
|
|
18
18
|
# @rbs return: Integer | Skyward::ORM::Violation
|
|
19
19
|
def delete
|
|
20
|
-
sql, binds = deleting
|
|
20
|
+
sql, binds = deleting(nil)
|
|
21
21
|
@session.database.write(@table, sql, binds)
|
|
22
22
|
end
|
|
23
23
|
|
data/lib/skyward/orm/record.rb
CHANGED
|
@@ -6,12 +6,15 @@ class Skyward::ORM::Record
|
|
|
6
6
|
# Each table class defines these for its columns, from Skyward::ORM::Tables::Rows.source.
|
|
7
7
|
# @rbs!
|
|
8
8
|
# private def initialize_columns: (Hash[Symbol, untyped] columns) -> void
|
|
9
|
+
# private def load_columns: (*untyped values) -> self
|
|
9
10
|
# def to_h: () -> Hash[Symbol, untyped]
|
|
11
|
+
# def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
|
12
|
+
# def inspect: () -> String
|
|
10
13
|
# def ==: (untyped other) -> bool
|
|
11
14
|
# def eql?: (untyped other) -> bool
|
|
12
15
|
# def hash: () -> Integer
|
|
13
16
|
|
|
14
|
-
# @dynamic initialize_columns, to_h, ==, eql?, hash
|
|
17
|
+
# @dynamic initialize_columns, load_columns, to_h, deconstruct_keys, inspect, ==, eql?, hash
|
|
15
18
|
class_eval(Skyward::ORM::Tables::Rows.source([]), __FILE__, __LINE__)
|
|
16
19
|
|
|
17
20
|
# @rbs return: Skyward::ORM::Query[instance]
|
|
@@ -57,7 +60,7 @@ class Skyward::ORM::Record
|
|
|
57
60
|
# @rbs return: Integer | Skyward::ORM::Violation
|
|
58
61
|
def self.insert(**values)
|
|
59
62
|
database = Skyward::ORM::Connection::SESSION.database
|
|
60
|
-
sql, binds = Skyward::ORM::Statements.insert(database
|
|
63
|
+
sql, binds = Skyward::ORM::Statements.insert(database, self, values, nil)
|
|
61
64
|
database.write(self, sql, binds)
|
|
62
65
|
end
|
|
63
66
|
|
|
@@ -108,11 +111,4 @@ class Skyward::ORM::Record
|
|
|
108
111
|
# @rbs **changes: untyped
|
|
109
112
|
# @rbs return: self
|
|
110
113
|
def with(**changes) = self.class.new(**to_h, **changes) #: self
|
|
111
|
-
|
|
112
|
-
# @rbs keys: Array[Symbol]?
|
|
113
|
-
# @rbs return: Hash[Symbol, untyped]
|
|
114
|
-
def deconstruct_keys(keys) = keys ? to_h.slice(*keys) : to_h
|
|
115
|
-
|
|
116
|
-
# @rbs return: String
|
|
117
|
-
def inspect = "#<#{self.class} #{to_h.map { |column, value| "#{column}=#{value.inspect}" }.join(", ")}>"
|
|
118
114
|
end
|
|
@@ -14,7 +14,7 @@ module Skyward::ORM::Statements::Placeholders
|
|
|
14
14
|
# @rbs return: String
|
|
15
15
|
def replace(sql, count)
|
|
16
16
|
marks = 0
|
|
17
|
-
replaced = sql.gsub(MARKS) { |match| match ==
|
|
17
|
+
replaced = sql.gsub(MARKS) { |match| match == '?' ? yield(marks += 1) : match }
|
|
18
18
|
return replaced if marks == count
|
|
19
19
|
|
|
20
20
|
raise ArgumentError, "The SQL has #{marks} ?, each taking one value, but was given #{count}"
|
|
@@ -28,8 +28,8 @@ module Skyward::ORM::Statements::Placeholders
|
|
|
28
28
|
def require_scalars(binds, subject)
|
|
29
29
|
binds.each.with_index(1) do |bind, index|
|
|
30
30
|
kind = case bind
|
|
31
|
-
when Array then
|
|
32
|
-
when Hash then
|
|
31
|
+
when Array then 'an Array'
|
|
32
|
+
when Hash then 'a Hash'
|
|
33
33
|
end
|
|
34
34
|
raise ArgumentError, "#{subject} binds one value to each ?, but value #{index} is #{kind}" if kind
|
|
35
35
|
end
|