sequel 5.33.0 → 5.58.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/CHANGELOG +318 -0
- data/MIT-LICENSE +1 -1
- data/README.rdoc +40 -9
- data/doc/association_basics.rdoc +77 -13
- data/doc/cheat_sheet.rdoc +13 -5
- data/doc/code_order.rdoc +0 -12
- data/doc/dataset_filtering.rdoc +2 -2
- data/doc/fork_safety.rdoc +84 -0
- data/doc/migration.rdoc +12 -6
- data/doc/model_plugins.rdoc +1 -1
- data/doc/opening_databases.rdoc +15 -3
- data/doc/postgresql.rdoc +9 -1
- data/doc/querying.rdoc +7 -5
- data/doc/release_notes/5.34.0.txt +40 -0
- data/doc/release_notes/5.35.0.txt +56 -0
- data/doc/release_notes/5.36.0.txt +60 -0
- data/doc/release_notes/5.37.0.txt +30 -0
- data/doc/release_notes/5.38.0.txt +28 -0
- data/doc/release_notes/5.39.0.txt +19 -0
- data/doc/release_notes/5.40.0.txt +40 -0
- data/doc/release_notes/5.41.0.txt +25 -0
- data/doc/release_notes/5.42.0.txt +136 -0
- data/doc/release_notes/5.43.0.txt +98 -0
- data/doc/release_notes/5.44.0.txt +32 -0
- data/doc/release_notes/5.45.0.txt +34 -0
- data/doc/release_notes/5.46.0.txt +87 -0
- data/doc/release_notes/5.47.0.txt +59 -0
- data/doc/release_notes/5.48.0.txt +14 -0
- data/doc/release_notes/5.49.0.txt +59 -0
- data/doc/release_notes/5.50.0.txt +78 -0
- data/doc/release_notes/5.51.0.txt +47 -0
- data/doc/release_notes/5.52.0.txt +87 -0
- data/doc/release_notes/5.53.0.txt +23 -0
- data/doc/release_notes/5.54.0.txt +27 -0
- data/doc/release_notes/5.55.0.txt +21 -0
- data/doc/release_notes/5.56.0.txt +51 -0
- data/doc/release_notes/5.57.0.txt +23 -0
- data/doc/release_notes/5.58.0.txt +31 -0
- data/doc/sql.rdoc +14 -2
- data/doc/testing.rdoc +10 -1
- data/doc/transactions.rdoc +0 -8
- data/doc/validations.rdoc +1 -1
- data/doc/virtual_rows.rdoc +1 -1
- data/lib/sequel/adapters/ado/access.rb +1 -1
- data/lib/sequel/adapters/ado.rb +17 -17
- data/lib/sequel/adapters/amalgalite.rb +3 -5
- data/lib/sequel/adapters/ibmdb.rb +2 -2
- data/lib/sequel/adapters/jdbc/derby.rb +8 -0
- data/lib/sequel/adapters/jdbc/h2.rb +60 -10
- data/lib/sequel/adapters/jdbc/hsqldb.rb +6 -0
- data/lib/sequel/adapters/jdbc/mysql.rb +4 -4
- data/lib/sequel/adapters/jdbc/postgresql.rb +4 -4
- data/lib/sequel/adapters/jdbc.rb +29 -19
- data/lib/sequel/adapters/mysql.rb +80 -67
- data/lib/sequel/adapters/mysql2.rb +54 -49
- data/lib/sequel/adapters/odbc.rb +8 -6
- data/lib/sequel/adapters/oracle.rb +5 -4
- data/lib/sequel/adapters/postgres.rb +27 -29
- data/lib/sequel/adapters/shared/access.rb +2 -0
- data/lib/sequel/adapters/shared/db2.rb +30 -0
- data/lib/sequel/adapters/shared/mssql.rb +84 -7
- data/lib/sequel/adapters/shared/mysql.rb +33 -2
- data/lib/sequel/adapters/shared/oracle.rb +82 -7
- data/lib/sequel/adapters/shared/postgres.rb +158 -20
- data/lib/sequel/adapters/shared/sqlanywhere.rb +3 -0
- data/lib/sequel/adapters/shared/sqlite.rb +102 -10
- data/lib/sequel/adapters/sqlanywhere.rb +1 -1
- data/lib/sequel/adapters/sqlite.rb +60 -18
- data/lib/sequel/adapters/tinytds.rb +2 -1
- data/lib/sequel/adapters/utils/columns_limit_1.rb +22 -0
- data/lib/sequel/adapters/utils/mysql_mysql2.rb +2 -1
- data/lib/sequel/ast_transformer.rb +6 -0
- data/lib/sequel/connection_pool/sharded_single.rb +9 -8
- data/lib/sequel/connection_pool/sharded_threaded.rb +10 -10
- data/lib/sequel/connection_pool/single.rb +7 -9
- data/lib/sequel/connection_pool/threaded.rb +1 -1
- data/lib/sequel/core.rb +33 -24
- data/lib/sequel/database/connecting.rb +3 -4
- data/lib/sequel/database/misc.rb +37 -12
- data/lib/sequel/database/query.rb +3 -1
- data/lib/sequel/database/schema_generator.rb +50 -53
- data/lib/sequel/database/schema_methods.rb +45 -23
- data/lib/sequel/database/transactions.rb +9 -6
- data/lib/sequel/dataset/actions.rb +61 -8
- data/lib/sequel/dataset/features.rb +15 -0
- data/lib/sequel/dataset/placeholder_literalizer.rb +3 -7
- data/lib/sequel/dataset/prepared_statements.rb +2 -0
- data/lib/sequel/dataset/query.rb +114 -11
- data/lib/sequel/dataset/sql.rb +172 -46
- data/lib/sequel/deprecated.rb +3 -1
- data/lib/sequel/exceptions.rb +2 -0
- data/lib/sequel/extensions/_pretty_table.rb +1 -2
- data/lib/sequel/extensions/any_not_empty.rb +1 -1
- data/lib/sequel/extensions/async_thread_pool.rb +438 -0
- data/lib/sequel/extensions/blank.rb +8 -0
- data/lib/sequel/extensions/columns_introspection.rb +1 -2
- data/lib/sequel/extensions/core_refinements.rb +38 -11
- data/lib/sequel/extensions/date_arithmetic.rb +36 -24
- data/lib/sequel/extensions/date_parse_input_handler.rb +67 -0
- data/lib/sequel/extensions/datetime_parse_to_time.rb +5 -1
- data/lib/sequel/extensions/duplicate_columns_handler.rb +3 -1
- data/lib/sequel/extensions/eval_inspect.rb +2 -0
- data/lib/sequel/extensions/inflector.rb +9 -1
- data/lib/sequel/extensions/is_distinct_from.rb +139 -0
- data/lib/sequel/extensions/migration.rb +13 -2
- data/lib/sequel/extensions/named_timezones.rb +5 -1
- data/lib/sequel/extensions/pagination.rb +1 -1
- data/lib/sequel/extensions/pg_array.rb +1 -0
- data/lib/sequel/extensions/pg_array_ops.rb +6 -2
- data/lib/sequel/extensions/pg_enum.rb +3 -1
- data/lib/sequel/extensions/pg_extended_date_support.rb +2 -2
- data/lib/sequel/extensions/pg_hstore.rb +1 -1
- data/lib/sequel/extensions/pg_hstore_ops.rb +55 -3
- data/lib/sequel/extensions/pg_inet.rb +2 -0
- data/lib/sequel/extensions/pg_inet_ops.rb +1 -1
- data/lib/sequel/extensions/pg_interval.rb +35 -8
- data/lib/sequel/extensions/pg_json.rb +3 -5
- data/lib/sequel/extensions/pg_json_ops.rb +119 -4
- data/lib/sequel/extensions/pg_loose_count.rb +3 -1
- data/lib/sequel/extensions/pg_multirange.rb +372 -0
- data/lib/sequel/extensions/pg_range.rb +7 -19
- data/lib/sequel/extensions/pg_range_ops.rb +39 -9
- data/lib/sequel/extensions/pg_row.rb +1 -1
- data/lib/sequel/extensions/pg_row_ops.rb +25 -1
- data/lib/sequel/extensions/query.rb +3 -0
- data/lib/sequel/extensions/run_transaction_hooks.rb +1 -1
- data/lib/sequel/extensions/s.rb +4 -1
- data/lib/sequel/extensions/schema_dumper.rb +16 -5
- data/lib/sequel/extensions/server_block.rb +8 -12
- data/lib/sequel/extensions/sql_comments.rb +110 -3
- data/lib/sequel/extensions/sql_log_normalizer.rb +108 -0
- data/lib/sequel/extensions/sqlite_json_ops.rb +255 -0
- data/lib/sequel/extensions/string_agg.rb +1 -1
- data/lib/sequel/extensions/string_date_time.rb +19 -23
- data/lib/sequel/extensions/symbol_aref_refinement.rb +2 -0
- data/lib/sequel/extensions/symbol_as_refinement.rb +2 -0
- data/lib/sequel/extensions/to_dot.rb +9 -3
- data/lib/sequel/model/associations.rb +342 -114
- data/lib/sequel/model/base.rb +45 -24
- data/lib/sequel/model/errors.rb +10 -1
- data/lib/sequel/model/inflections.rb +1 -1
- data/lib/sequel/model/plugins.rb +8 -3
- data/lib/sequel/model.rb +3 -1
- data/lib/sequel/plugins/association_pks.rb +60 -18
- data/lib/sequel/plugins/association_proxies.rb +3 -0
- data/lib/sequel/plugins/async_thread_pool.rb +39 -0
- data/lib/sequel/plugins/auto_restrict_eager_graph.rb +62 -0
- data/lib/sequel/plugins/auto_validations.rb +39 -5
- data/lib/sequel/plugins/auto_validations_constraint_validations_presence_message.rb +68 -0
- data/lib/sequel/plugins/blacklist_security.rb +1 -2
- data/lib/sequel/plugins/class_table_inheritance.rb +3 -8
- data/lib/sequel/plugins/column_encryption.rb +728 -0
- data/lib/sequel/plugins/composition.rb +8 -2
- data/lib/sequel/plugins/concurrent_eager_loading.rb +174 -0
- data/lib/sequel/plugins/constraint_validations.rb +2 -1
- data/lib/sequel/plugins/csv_serializer.rb +2 -0
- data/lib/sequel/plugins/dataset_associations.rb +4 -1
- data/lib/sequel/plugins/dirty.rb +44 -0
- data/lib/sequel/plugins/enum.rb +124 -0
- data/lib/sequel/plugins/forbid_lazy_load.rb +2 -0
- data/lib/sequel/plugins/insert_conflict.rb +4 -0
- data/lib/sequel/plugins/instance_specific_default.rb +113 -0
- data/lib/sequel/plugins/json_serializer.rb +39 -24
- data/lib/sequel/plugins/lazy_attributes.rb +4 -1
- data/lib/sequel/plugins/many_through_many.rb +108 -9
- data/lib/sequel/plugins/nested_attributes.rb +8 -3
- data/lib/sequel/plugins/pg_array_associations.rb +58 -41
- data/lib/sequel/plugins/pg_auto_constraint_validations.rb +2 -0
- data/lib/sequel/plugins/prepared_statements.rb +15 -12
- data/lib/sequel/plugins/prepared_statements_safe.rb +1 -3
- data/lib/sequel/plugins/rcte_tree.rb +37 -35
- data/lib/sequel/plugins/serialization.rb +9 -3
- data/lib/sequel/plugins/serialization_modification_detection.rb +2 -1
- data/lib/sequel/plugins/single_table_inheritance.rb +7 -0
- data/lib/sequel/plugins/sql_comments.rb +189 -0
- data/lib/sequel/plugins/static_cache.rb +1 -1
- data/lib/sequel/plugins/string_stripper.rb +1 -1
- data/lib/sequel/plugins/subclasses.rb +28 -11
- data/lib/sequel/plugins/tactical_eager_loading.rb +8 -2
- data/lib/sequel/plugins/timestamps.rb +1 -1
- data/lib/sequel/plugins/tree.rb +9 -4
- data/lib/sequel/plugins/unused_associations.rb +521 -0
- data/lib/sequel/plugins/update_or_create.rb +1 -1
- data/lib/sequel/plugins/validation_class_methods.rb +5 -1
- data/lib/sequel/plugins/validation_helpers.rb +18 -11
- data/lib/sequel/plugins/xml_serializer.rb +1 -1
- data/lib/sequel/sql.rb +1 -1
- data/lib/sequel/timezones.rb +20 -17
- data/lib/sequel/version.rb +1 -1
- metadata +93 -39
@@ -0,0 +1,438 @@
|
|
1
|
+
# frozen-string-literal: true
|
2
|
+
#
|
3
|
+
# The async_thread_pool extension adds support for running database
|
4
|
+
# queries in a separate threads using a thread pool. With the following
|
5
|
+
# code
|
6
|
+
#
|
7
|
+
# DB.extension :async_thread_pool
|
8
|
+
# foos = DB[:foos].async.where{:name=>'A'..'M'}.all
|
9
|
+
# bar_names = DB[:bar].async.select_order_map(:name)
|
10
|
+
# baz_1 = DB[:bazes].async.first(:id=>1)
|
11
|
+
#
|
12
|
+
# All 3 queries will be run in separate threads. +foos+, +bar_names+
|
13
|
+
# and +baz_1+ will be proxy objects. Calling a method on the proxy
|
14
|
+
# object will wait for the query to be run, and will return the result
|
15
|
+
# of calling that method on the result of the query method. For example,
|
16
|
+
# if you run:
|
17
|
+
#
|
18
|
+
# foos = DB[:foos].async.where{:name=>'A'..'M'}.all
|
19
|
+
# bar_names = DB[:bars].async.select_order_map(:name)
|
20
|
+
# baz_1 = DB[:bazes].async.first(:id=>1)
|
21
|
+
# sleep(1)
|
22
|
+
# foos.size
|
23
|
+
# bar_names.first
|
24
|
+
# baz_1.name
|
25
|
+
#
|
26
|
+
# These three queries will generally be run concurrently in separate
|
27
|
+
# threads. If you instead run:
|
28
|
+
#
|
29
|
+
# DB[:foos].async.where{:name=>'A'..'M'}.all.size
|
30
|
+
# DB[:bars].async.select_order_map(:name).first
|
31
|
+
# DB[:bazes].async.first(:id=>1).name
|
32
|
+
#
|
33
|
+
# Then will run each query sequentially, since you need the result of
|
34
|
+
# one query before running the next query. The queries will still be
|
35
|
+
# run in separate threads (by default).
|
36
|
+
#
|
37
|
+
# What is run in the separate thread is the entire method call that
|
38
|
+
# returns results. So with the original example:
|
39
|
+
#
|
40
|
+
# foos = DB[:foos].async.where{:name=>'A'..'M'}.all
|
41
|
+
# bar_names = DB[:bars].async.select_order_map(:name)
|
42
|
+
# baz_1 = DB[:bazes].async.first(:id=>1)
|
43
|
+
#
|
44
|
+
# The +all+, <tt>select_order_map(:name)</tt>, and <tt>first(:id=>1)</tt>
|
45
|
+
# calls are run in separate threads. If a block is passed to a method
|
46
|
+
# such as +all+ or +each+, the block is also run in that thread. If you
|
47
|
+
# have code such as:
|
48
|
+
#
|
49
|
+
# h = {}
|
50
|
+
# DB[:foos].async.each{|row| h[row[:id]] = row}
|
51
|
+
# bar_names = DB[:bars].async.select_order_map(:name)
|
52
|
+
# p h
|
53
|
+
#
|
54
|
+
# You may end up with it printing an empty hash or partial hash, because the
|
55
|
+
# async +each+ call will not have run or finished running. Since the
|
56
|
+
# <tt>p h</tt> code relies on a side-effect of the +each+ block and not the
|
57
|
+
# return value of the +each+ call, it will not wait for the loading.
|
58
|
+
#
|
59
|
+
# You should avoid using +async+ for any queries where you are ignoring the
|
60
|
+
# return value, as otherwise you have no way to wait for the query to be run.
|
61
|
+
#
|
62
|
+
# Datasets that use async will use async threads to load data for the majority
|
63
|
+
# of methods that can return data. However, dataset methods that return
|
64
|
+
# enumerators will not use an async thread (e.g. calling # Dataset#map
|
65
|
+
# without a block or arguments does not use an async thread or return a
|
66
|
+
# proxy object).
|
67
|
+
#
|
68
|
+
# Because async methods (including their blocks) run in a separate thread, you
|
69
|
+
# should not use control flow modifiers such as +return+ or +break+ in async
|
70
|
+
# queries. Doing so will result in a error.
|
71
|
+
#
|
72
|
+
# Because async results are returned as proxy objects, it's a bad idea
|
73
|
+
# to use them in a boolean setting:
|
74
|
+
#
|
75
|
+
# result = DB[:foo].async.get(:boolean_column)
|
76
|
+
# # or:
|
77
|
+
# result = DB[:foo].async.first
|
78
|
+
#
|
79
|
+
# # ...
|
80
|
+
# if result
|
81
|
+
# # will always execute this banch, since result is a proxy object
|
82
|
+
# end
|
83
|
+
#
|
84
|
+
# In this case, you can call the +__value+ method to return the actual
|
85
|
+
# result:
|
86
|
+
#
|
87
|
+
# if result.__value
|
88
|
+
# # will not execute this branch if the dataset method returned nil or false
|
89
|
+
# end
|
90
|
+
#
|
91
|
+
# Similarly, because a proxy object is used, you should be careful using the
|
92
|
+
# result in a case statement or an argument to <tt>Class#===</tt>:
|
93
|
+
#
|
94
|
+
# # ...
|
95
|
+
# case result
|
96
|
+
# when Hash, true, false
|
97
|
+
# # will never take this branch, since result is a proxy object
|
98
|
+
# end
|
99
|
+
#
|
100
|
+
# Similar to usage in an +if+ statement, you should use +__value+:
|
101
|
+
#
|
102
|
+
# case result.__value
|
103
|
+
# when Hash, true, false
|
104
|
+
# # will never take this branch, since result is a proxy object
|
105
|
+
# end
|
106
|
+
#
|
107
|
+
# On Ruby 2.2+, you can use +itself+ instead of +__value+. It's preferable to
|
108
|
+
# use +itself+ if you can, as that will allow code to work with both proxy
|
109
|
+
# objects and regular objects.
|
110
|
+
#
|
111
|
+
# Because separate threads and connections are used for async queries,
|
112
|
+
# they do not use any state on the current connection/thread. So if
|
113
|
+
# you do:
|
114
|
+
#
|
115
|
+
# DB.transaction{DB[:table].async.all}
|
116
|
+
#
|
117
|
+
# Be aware that the transaction runs on one connection, and the SELECT
|
118
|
+
# query on a different connection. If you use currently using
|
119
|
+
# transactional testing (running each test inside a transaction/savepoint),
|
120
|
+
# and want to start using this extension, you should first switch to
|
121
|
+
# non-transactional testing of the code that will use the async thread
|
122
|
+
# pool before using this extension, as otherwise the use of
|
123
|
+
# <tt>Dataset#async</tt> will likely break your tests.
|
124
|
+
#
|
125
|
+
# If you are using Database#synchronize to checkout a connection, the
|
126
|
+
# same issue applies, where the async query runs on a different
|
127
|
+
# connection:
|
128
|
+
#
|
129
|
+
# DB.synchronize{DB[:table].async.all}
|
130
|
+
#
|
131
|
+
# Similarly, if you are using the server_block extension, any async
|
132
|
+
# queries inside with_server blocks will not use the server specified:
|
133
|
+
#
|
134
|
+
# DB.with_server(:shard1) do
|
135
|
+
# DB[:a].all # Uses shard1
|
136
|
+
# DB[:a].async.all # Uses default shard
|
137
|
+
# end
|
138
|
+
#
|
139
|
+
# You need to manually specify the shard for any dataset using an async
|
140
|
+
# query:
|
141
|
+
#
|
142
|
+
# DB.with_server(:shard1) do
|
143
|
+
# DB[:a].all # Uses shard1
|
144
|
+
# DB[:a].async.server(:shard1).all # Uses shard1
|
145
|
+
# end
|
146
|
+
#
|
147
|
+
# When the async_thread_pool extension, the size of the async thread pool
|
148
|
+
# can be set by using the +:num_async_threads+ Database option, which must
|
149
|
+
# be set before loading the async_thread_pool extension. This defaults
|
150
|
+
# to the size of the Database object's connection pool.
|
151
|
+
#
|
152
|
+
# By default, for consistent behavior, the async_thread_pool extension
|
153
|
+
# will always run the query in a separate thread. However, in some cases,
|
154
|
+
# such as when the async thread pool is busy and the results of a query
|
155
|
+
# are needed right away, it can improve performance to allow preemption,
|
156
|
+
# so that the query will run in the current thread instead of waiting
|
157
|
+
# for an async thread to become available. With the following code:
|
158
|
+
#
|
159
|
+
# foos = DB[:foos].async.where{:name=>'A'..'M'}.all
|
160
|
+
# bar_names = DB[:bar].async.select_order_map(:name)
|
161
|
+
# if foos.length > 4
|
162
|
+
# baz_1 = DB[:bazes].async.first(:id=>1)
|
163
|
+
# end
|
164
|
+
#
|
165
|
+
# Whether you need the +baz_1+ variable depends on the value of foos.
|
166
|
+
# If the async thread pool is busy, and by the time the +foos.length+
|
167
|
+
# call is made, the async thread pool has not started the processing
|
168
|
+
# to get the +foos+ value, it can improve performance to start that
|
169
|
+
# processing in the current thread, since it is needed immediately to
|
170
|
+
# determine whether to schedule query to get the +baz_1+ variable.
|
171
|
+
# The default is to not allow preemption, because if the current
|
172
|
+
# thread is used, it may have already checked out a connection that
|
173
|
+
# could be used, and that connection could be inside a transaction or
|
174
|
+
# have some other manner of connection-specific state applied to it.
|
175
|
+
# If you want to allow preemption, you can set the
|
176
|
+
# +:preempt_async_thread+ Database option before loading the
|
177
|
+
# async_thread_pool extension.
|
178
|
+
#
|
179
|
+
# Related module: Sequel::Database::AsyncThreadPool::DatasetMethods
|
180
|
+
|
181
|
+
|
182
|
+
#
|
183
|
+
module Sequel
|
184
|
+
module Database::AsyncThreadPool
|
185
|
+
# JobProcessor is a wrapper around a single thread, that will
|
186
|
+
# process a queue of jobs until it is shut down.
|
187
|
+
class JobProcessor # :nodoc:
|
188
|
+
def self.create_finalizer(queue, pool)
|
189
|
+
proc{run_finalizer(queue, pool)}
|
190
|
+
end
|
191
|
+
|
192
|
+
def self.run_finalizer(queue, pool)
|
193
|
+
# Push a nil for each thread using the queue, signalling
|
194
|
+
# that thread to close.
|
195
|
+
pool.each{queue.push(nil)}
|
196
|
+
|
197
|
+
# Join each of the closed threads.
|
198
|
+
pool.each(&:join)
|
199
|
+
|
200
|
+
# Clear the thread pool. Probably not necessary, but this allows
|
201
|
+
# for a simple way to check whether this finalizer has been run.
|
202
|
+
pool.clear
|
203
|
+
|
204
|
+
nil
|
205
|
+
end
|
206
|
+
private_class_method :run_finalizer
|
207
|
+
|
208
|
+
def initialize(queue)
|
209
|
+
@thread = ::Thread.new do
|
210
|
+
while proxy = queue.pop
|
211
|
+
proxy.__send__(:__run)
|
212
|
+
end
|
213
|
+
end
|
214
|
+
end
|
215
|
+
|
216
|
+
# Join the thread, should only be called by the related finalizer.
|
217
|
+
def join
|
218
|
+
@thread.join
|
219
|
+
end
|
220
|
+
end
|
221
|
+
|
222
|
+
# Wrapper for exception instances raised by async jobs. The
|
223
|
+
# wrapped exception will be raised by the code getting the value
|
224
|
+
# of the job.
|
225
|
+
WrappedException = Struct.new(:exception)
|
226
|
+
|
227
|
+
# Base proxy object class for jobs processed by async threads and
|
228
|
+
# the returned result.
|
229
|
+
class BaseProxy < BasicObject
|
230
|
+
# Store a block that returns the result when called.
|
231
|
+
def initialize(&block)
|
232
|
+
::Kernel.raise Error, "must provide block for an async job" unless block
|
233
|
+
@block = block
|
234
|
+
end
|
235
|
+
|
236
|
+
# Pass all method calls to the returned result.
|
237
|
+
def method_missing(*args, &block)
|
238
|
+
__value.public_send(*args, &block)
|
239
|
+
end
|
240
|
+
# :nocov:
|
241
|
+
ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
|
242
|
+
# :nocov:
|
243
|
+
|
244
|
+
# Delegate respond_to? calls to the returned result.
|
245
|
+
def respond_to_missing?(*args)
|
246
|
+
__value.respond_to?(*args)
|
247
|
+
end
|
248
|
+
|
249
|
+
# Override some methods defined by default so they apply to the
|
250
|
+
# returned result and not the current object.
|
251
|
+
[:!, :==, :!=, :instance_eval, :instance_exec].each do |method|
|
252
|
+
define_method(method) do |*args, &block|
|
253
|
+
__value.public_send(method, *args, &block)
|
254
|
+
end
|
255
|
+
end
|
256
|
+
|
257
|
+
# Wait for the value to be loaded if it hasn't already been loaded.
|
258
|
+
# If the code to load the return value raised an exception that was
|
259
|
+
# wrapped, reraise the exception.
|
260
|
+
def __value
|
261
|
+
unless defined?(@value)
|
262
|
+
__get_value
|
263
|
+
end
|
264
|
+
|
265
|
+
if @value.is_a?(WrappedException)
|
266
|
+
::Kernel.raise @value
|
267
|
+
end
|
268
|
+
|
269
|
+
@value
|
270
|
+
end
|
271
|
+
|
272
|
+
private
|
273
|
+
|
274
|
+
# Run the block and return the block value. If the block call raises
|
275
|
+
# an exception, wrap the exception.
|
276
|
+
def __run_block
|
277
|
+
# This may not catch concurrent calls (unless surrounded by a mutex), but
|
278
|
+
# it's not worth trying to protect against that. It's enough to just check for
|
279
|
+
# multiple non-concurrent calls.
|
280
|
+
::Kernel.raise Error, "Cannot run async block multiple times" unless block = @block
|
281
|
+
|
282
|
+
@block = nil
|
283
|
+
|
284
|
+
begin
|
285
|
+
block.call
|
286
|
+
rescue ::Exception => e
|
287
|
+
WrappedException.new(e)
|
288
|
+
end
|
289
|
+
end
|
290
|
+
end
|
291
|
+
|
292
|
+
# Default object class for async job/proxy result. This uses a queue for
|
293
|
+
# synchronization. The JobProcessor will push a result until the queue,
|
294
|
+
# and the code to get the value will pop the result from that queue (and
|
295
|
+
# repush the result to handle thread safety).
|
296
|
+
class Proxy < BaseProxy
|
297
|
+
def initialize
|
298
|
+
super
|
299
|
+
@queue = ::Queue.new
|
300
|
+
end
|
301
|
+
|
302
|
+
private
|
303
|
+
|
304
|
+
def __run
|
305
|
+
@queue.push(__run_block)
|
306
|
+
end
|
307
|
+
|
308
|
+
def __get_value
|
309
|
+
@value = @queue.pop
|
310
|
+
|
311
|
+
# Handle thread-safety by repushing the popped value, so that
|
312
|
+
# concurrent calls will receive the same value
|
313
|
+
@queue.push(@value)
|
314
|
+
end
|
315
|
+
end
|
316
|
+
|
317
|
+
# Object class for async job/proxy result when the :preempt_async_thread
|
318
|
+
# Database option is used. Uses a mutex for synchronization, and either
|
319
|
+
# the JobProcessor or the calling thread can run code to get the value.
|
320
|
+
class PreemptableProxy < BaseProxy
|
321
|
+
def initialize
|
322
|
+
super
|
323
|
+
@mutex = ::Mutex.new
|
324
|
+
end
|
325
|
+
|
326
|
+
private
|
327
|
+
|
328
|
+
def __get_value
|
329
|
+
@mutex.synchronize do
|
330
|
+
unless defined?(@value)
|
331
|
+
@value = __run_block
|
332
|
+
end
|
333
|
+
end
|
334
|
+
end
|
335
|
+
alias __run __get_value
|
336
|
+
end
|
337
|
+
|
338
|
+
module DatabaseMethods
|
339
|
+
def self.extended(db)
|
340
|
+
db.instance_exec do
|
341
|
+
unless pool.pool_type == :threaded || pool.pool_type == :sharded_threaded
|
342
|
+
raise Error, "can only load async_thread_pool extension if using threaded or sharded_threaded connection pool"
|
343
|
+
end
|
344
|
+
|
345
|
+
num_async_threads = opts[:num_async_threads] ? typecast_value_integer(opts[:num_async_threads]) : (Integer(opts[:max_connections] || 4))
|
346
|
+
raise Error, "must have positive number for num_async_threads" if num_async_threads <= 0
|
347
|
+
|
348
|
+
proxy_klass = typecast_value_boolean(opts[:preempt_async_thread]) ? PreemptableProxy : Proxy
|
349
|
+
define_singleton_method(:async_job_class){proxy_klass}
|
350
|
+
|
351
|
+
queue = @async_thread_queue = Queue.new
|
352
|
+
pool = @async_thread_pool = num_async_threads.times.map{JobProcessor.new(queue)}
|
353
|
+
ObjectSpace.define_finalizer(db, JobProcessor.create_finalizer(queue, pool))
|
354
|
+
|
355
|
+
extend_datasets(DatasetMethods)
|
356
|
+
end
|
357
|
+
end
|
358
|
+
|
359
|
+
private
|
360
|
+
|
361
|
+
# Wrap the block in a job/proxy object and schedule it to run using the async thread pool.
|
362
|
+
def async_run(&block)
|
363
|
+
proxy = async_job_class.new(&block)
|
364
|
+
@async_thread_queue.push(proxy)
|
365
|
+
proxy
|
366
|
+
end
|
367
|
+
end
|
368
|
+
|
369
|
+
ASYNC_METHODS = ([:all?, :any?, :drop, :entries, :grep_v, :include?, :inject, :member?, :minmax, :none?, :one?, :reduce, :sort, :take, :tally, :to_a, :to_h, :uniq, :zip] & Enumerable.instance_methods) + (Dataset::ACTION_METHODS - [:map, :paged_each])
|
370
|
+
ASYNC_BLOCK_METHODS = ([:collect, :collect_concat, :detect, :drop_while, :each_cons, :each_entry, :each_slice, :each_with_index, :each_with_object, :filter_map, :find, :find_all, :find_index, :flat_map, :max_by, :min_by, :minmax_by, :partition, :reject, :reverse_each, :sort_by, :take_while] & Enumerable.instance_methods) + [:paged_each]
|
371
|
+
ASYNC_ARGS_OR_BLOCK_METHODS = [:map]
|
372
|
+
|
373
|
+
module DatasetMethods
|
374
|
+
# Define an method in the given module that will run the given method using an async thread
|
375
|
+
# if the current dataset is async.
|
376
|
+
def self.define_async_method(mod, method)
|
377
|
+
mod.send(:define_method, method) do |*args, &block|
|
378
|
+
if @opts[:async]
|
379
|
+
ds = sync
|
380
|
+
db.send(:async_run){ds.send(method, *args, &block)}
|
381
|
+
else
|
382
|
+
super(*args, &block)
|
383
|
+
end
|
384
|
+
end
|
385
|
+
end
|
386
|
+
|
387
|
+
# Define an method in the given module that will run the given method using an async thread
|
388
|
+
# if the current dataset is async and a block is provided.
|
389
|
+
def self.define_async_block_method(mod, method)
|
390
|
+
mod.send(:define_method, method) do |*args, &block|
|
391
|
+
if block && @opts[:async]
|
392
|
+
ds = sync
|
393
|
+
db.send(:async_run){ds.send(method, *args, &block)}
|
394
|
+
else
|
395
|
+
super(*args, &block)
|
396
|
+
end
|
397
|
+
end
|
398
|
+
end
|
399
|
+
|
400
|
+
# Define an method in the given module that will run the given method using an async thread
|
401
|
+
# if the current dataset is async and arguments or a block is provided.
|
402
|
+
def self.define_async_args_or_block_method(mod, method)
|
403
|
+
mod.send(:define_method, method) do |*args, &block|
|
404
|
+
if (block || !args.empty?) && @opts[:async]
|
405
|
+
ds = sync
|
406
|
+
db.send(:async_run){ds.send(method, *args, &block)}
|
407
|
+
else
|
408
|
+
super(*args, &block)
|
409
|
+
end
|
410
|
+
end
|
411
|
+
end
|
412
|
+
|
413
|
+
# Override all of the methods that return results to do the processing in an async thread
|
414
|
+
# if they have been marked to run async and should run async (i.e. they don't return an
|
415
|
+
# Enumerator).
|
416
|
+
ASYNC_METHODS.each{|m| define_async_method(self, m)}
|
417
|
+
ASYNC_BLOCK_METHODS.each{|m| define_async_block_method(self, m)}
|
418
|
+
ASYNC_ARGS_OR_BLOCK_METHODS.each{|m| define_async_args_or_block_method(self, m)}
|
419
|
+
|
420
|
+
# Return a cloned dataset that will load results using the async thread pool.
|
421
|
+
def async
|
422
|
+
cached_dataset(:_async) do
|
423
|
+
clone(:async=>true)
|
424
|
+
end
|
425
|
+
end
|
426
|
+
|
427
|
+
# Return a cloned dataset that will not load results using the async thread pool.
|
428
|
+
# Only used if the current dataset has been marked as using the async thread pool.
|
429
|
+
def sync
|
430
|
+
cached_dataset(:_sync) do
|
431
|
+
clone(:async=>false)
|
432
|
+
end
|
433
|
+
end
|
434
|
+
end
|
435
|
+
end
|
436
|
+
|
437
|
+
Database.register_extension(:async_thread_pool, Database::AsyncThreadPool::DatabaseMethods)
|
438
|
+
end
|
@@ -6,6 +6,14 @@
|
|
6
6
|
#
|
7
7
|
# Sequel.extension :blank
|
8
8
|
|
9
|
+
[FalseClass, Object, NilClass, Numeric, String, TrueClass].each do |klass|
|
10
|
+
# :nocov:
|
11
|
+
if klass.method_defined?(:blank?)
|
12
|
+
klass.send(:alias_method, :blank?, :blank?)
|
13
|
+
end
|
14
|
+
# :nocov:
|
15
|
+
end
|
16
|
+
|
9
17
|
class FalseClass
|
10
18
|
# false is always blank
|
11
19
|
def blank?
|
@@ -75,8 +75,7 @@ module Sequel
|
|
75
75
|
when SQL::Identifier
|
76
76
|
c.value.to_sym
|
77
77
|
when SQL::QualifiedIdentifier
|
78
|
-
|
79
|
-
col.is_a?(SQL::Identifier) ? col.value.to_sym : col.to_sym
|
78
|
+
c.column.to_sym
|
80
79
|
when SQL::AliasedExpression
|
81
80
|
a = c.alias
|
82
81
|
a.is_a?(SQL::Identifier) ? a.value.to_sym : a.to_sym
|
@@ -10,9 +10,17 @@
|
|
10
10
|
#
|
11
11
|
# using Sequel::CoreRefinements
|
12
12
|
|
13
|
+
# :nocov:
|
13
14
|
raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
|
15
|
+
# :nocov:
|
14
16
|
|
15
17
|
module Sequel::CoreRefinements
|
18
|
+
# :nocov:
|
19
|
+
include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
|
20
|
+
# :nocov:
|
21
|
+
INCLUDE_METH = include_meth
|
22
|
+
private_constant :INCLUDE_METH
|
23
|
+
|
16
24
|
refine Array do
|
17
25
|
# Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, not matching all of the
|
18
26
|
# conditions.
|
@@ -159,8 +167,8 @@ module Sequel::CoreRefinements
|
|
159
167
|
end
|
160
168
|
|
161
169
|
refine String do
|
162
|
-
|
163
|
-
|
170
|
+
send include_meth, Sequel::SQL::AliasMethods
|
171
|
+
send include_meth, Sequel::SQL::CastMethods
|
164
172
|
|
165
173
|
# Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
|
166
174
|
# literalization, e.g.:
|
@@ -187,15 +195,34 @@ module Sequel::CoreRefinements
|
|
187
195
|
end
|
188
196
|
|
189
197
|
refine Symbol do
|
190
|
-
|
191
|
-
|
192
|
-
|
193
|
-
|
194
|
-
|
195
|
-
|
196
|
-
|
197
|
-
|
198
|
-
|
198
|
+
send include_meth, Sequel::SQL::AliasMethods
|
199
|
+
send include_meth, Sequel::SQL::CastMethods
|
200
|
+
send include_meth, Sequel::SQL::OrderMethods
|
201
|
+
send include_meth, Sequel::SQL::BooleanMethods
|
202
|
+
send include_meth, Sequel::SQL::NumericMethods
|
203
|
+
|
204
|
+
# :nocov:
|
205
|
+
remove_method :* if RUBY_VERSION >= '3.1'
|
206
|
+
# :nocov:
|
207
|
+
|
208
|
+
send include_meth, Sequel::SQL::QualifyingMethods
|
209
|
+
send include_meth, Sequel::SQL::StringMethods
|
210
|
+
send include_meth, Sequel::SQL::SubscriptMethods
|
211
|
+
send include_meth, Sequel::SQL::ComplexExpressionMethods
|
212
|
+
|
213
|
+
# :nocov:
|
214
|
+
if RUBY_VERSION >= '3.1'
|
215
|
+
remove_method :*
|
216
|
+
def *(ce=(arg=false;nil))
|
217
|
+
if arg == false
|
218
|
+
Sequel::SQL::ColumnAll.new(self)
|
219
|
+
else
|
220
|
+
Sequel::SQL::NumericExpression.new(:*, self, ce)
|
221
|
+
end
|
222
|
+
end
|
223
|
+
|
224
|
+
end
|
225
|
+
# :nocov:
|
199
226
|
|
200
227
|
# Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.
|
201
228
|
#
|
@@ -8,9 +8,10 @@
|
|
8
8
|
# DB.extension :date_arithmetic
|
9
9
|
#
|
10
10
|
# Then you can use the Sequel.date_add and Sequel.date_sub methods
|
11
|
-
# to return Sequel expressions
|
11
|
+
# to return Sequel expressions (this example shows the only supported
|
12
|
+
# keys for the second argument):
|
12
13
|
#
|
13
|
-
# add = Sequel.date_add(:date_column, years: 1, months: 2, days:
|
14
|
+
# add = Sequel.date_add(:date_column, years: 1, months: 2, weeks: 2, days: 1)
|
14
15
|
# sub = Sequel.date_sub(:date_column, hours: 1, minutes: 2, seconds: 3)
|
15
16
|
#
|
16
17
|
# In addition to specifying the interval as a hash, there is also
|
@@ -49,14 +50,12 @@ module Sequel
|
|
49
50
|
# Options:
|
50
51
|
# :cast :: Cast to the specified type instead of the default if casting
|
51
52
|
def date_sub(expr, interval, opts=OPTS)
|
52
|
-
|
53
|
-
|
54
|
-
interval.each{|k,v| h[k] = -v unless v.nil?}
|
55
|
-
h
|
56
|
-
else
|
57
|
-
-interval
|
53
|
+
if defined?(ActiveSupport::Duration) && interval.is_a?(ActiveSupport::Duration)
|
54
|
+
interval = interval.parts
|
58
55
|
end
|
59
|
-
|
56
|
+
parts = {}
|
57
|
+
interval.each{|k,v| parts[k] = -v unless v.nil?}
|
58
|
+
DateAdd.new(expr, parts, opts)
|
60
59
|
end
|
61
60
|
end
|
62
61
|
|
@@ -113,12 +112,12 @@ module Sequel
|
|
113
112
|
end
|
114
113
|
when :mssql, :h2, :access, :sqlanywhere
|
115
114
|
units = case db_type
|
116
|
-
when :mssql, :sqlanywhere
|
117
|
-
MSSQL_DURATION_UNITS
|
118
115
|
when :h2
|
119
116
|
H2_DURATION_UNITS
|
120
117
|
when :access
|
121
118
|
ACCESS_DURATION_UNITS
|
119
|
+
else
|
120
|
+
MSSQL_DURATION_UNITS
|
122
121
|
end
|
123
122
|
each_valid_interval_unit(h, units) do |value, sql_unit|
|
124
123
|
expr = Sequel.function(:DATEADD, sql_unit, value, expr)
|
@@ -186,22 +185,35 @@ module Sequel
|
|
186
185
|
# ActiveSupport::Duration :: Converted to a hash using the interval's parts.
|
187
186
|
def initialize(expr, interval, opts=OPTS)
|
188
187
|
@expr = expr
|
189
|
-
|
190
|
-
|
191
|
-
|
192
|
-
|
193
|
-
|
194
|
-
|
195
|
-
|
188
|
+
|
189
|
+
h = Hash.new(0)
|
190
|
+
interval = interval.parts unless interval.is_a?(Hash)
|
191
|
+
interval.each do |unit, value|
|
192
|
+
# skip nil values
|
193
|
+
next unless value
|
194
|
+
|
195
|
+
# Convert weeks to days, as ActiveSupport::Duration can use weeks,
|
196
|
+
# but the database-specific literalizers only support days.
|
197
|
+
if unit == :weeks
|
198
|
+
unit = :days
|
199
|
+
value *= 7
|
196
200
|
end
|
197
|
-
|
198
|
-
|
199
|
-
|
200
|
-
|
201
|
-
|
201
|
+
|
202
|
+
unless DatasetMethods::DURATION_UNITS.include?(unit)
|
203
|
+
raise Sequel::Error, "Invalid key used in DateAdd interval hash: #{unit.inspect}"
|
204
|
+
end
|
205
|
+
|
206
|
+
# Attempt to prevent SQL injection by users who pass untrusted strings
|
207
|
+
# as interval values. It doesn't make sense to support literal strings,
|
208
|
+
# due to the numeric adding below.
|
209
|
+
if value.is_a?(String)
|
210
|
+
raise Sequel::InvalidValue, "cannot provide String value as interval part: #{value.inspect}"
|
211
|
+
end
|
212
|
+
|
213
|
+
h[unit] += value
|
202
214
|
end
|
203
215
|
|
204
|
-
@interval.freeze
|
216
|
+
@interval = Hash[h].freeze
|
205
217
|
@cast_type = opts[:cast] if opts[:cast]
|
206
218
|
freeze
|
207
219
|
end
|