Bạn sẽ hiểu hơn về nó thông qua các ví dụ ở các phần tiếp theo. LOOP -- Làm gì đó tại đây. END LOOP;. Nhấn biểu tượng hoặc nhấn F8 để thực thi đoạn code. Một biến NUMBER cũng có thể mô tả 0.

DEC prec, scale Kiểu dấu chấm cố định, tiêu chuẩn ANSI với độ chính xác tối đa 38 số thâp phân. DECIMAL prec, scale Kiểu dấu chấm cố định, tiêu chuẩn IBM với độ chính xác tối đa 38 số thập phân. NUMERIC pre, secale Loại số thực Floating type với độ chính xác tối đa 38 số thập phân.

DOUBLE PRECISION Loại số chấm động, số thực, tiêu chuẩn ANSI với độ chính xác số nhị phân khoảng 38 số thập phân. FLOAT Loại số chấm động, số thực tiêu chuẩn ANSI và IBM với độ chính xác tối đa số nhị phân khoảng 38 số thập phân.

Để khai báo một biến có thể chứa giá trị của cột này bạn có thể khai báo theo cách dưới đây:. Select Emp. Bạn có thể định nghĩa ra kiểu dữ liệu Record , kiểu dữ liệu này chứa một vài cột.

Cú pháp:. Bạn có thể định nghĩa một kiểu dữ liệu mới, nó có thể lưu trữ nhiều phần tử, đó là kiểu TABLE. Các đặc điểm của kiểu TABLE : Kiểu dữ liệu TABLE giống như một mảng, nhưng có số phần tử không giới hạn. Chỉ số của kiểu TABLE không nhất thiết liên tục.

Ví dụ TABLE có 3 phần tử tại chỉ số 1, 3, 5. Declare -- Định nghĩa một kiểu TABLE. prior 2 ;. Declare -- Định nghĩa kiểu TABLE. Last; -- Lấy chỉ số tiếp theo của chỉ số cho bởi tham số. Một mảng có N phần tử. Các phần tử của mảng được đánh chỉ số liên tục bắt đầu từ 1 đến N.

Cursor là kiểu biến có cấu trúc, cho phép bạn xử lý dữ liệu gồm nhiều dòng. Số dòng phụ thuộc vào câu lệnh truy vấn dữ liệu sau nó. Trong quá trình xử lý, bạn có thể thao tác với Cursor thông qua từng dòng dữ liệu. Dòng dữ liệu này được định vị bởi một con trỏ. Với việc dịch chuyển con trỏ, bạn có thể lấy được toàn bộ dữ liệu của một dòng hiện tại.

Có hai loại con trỏ Cursor : Con trỏ tường minh Con trỏ không tường minh. Khái niệm tường minh ở đây có nghĩa là, khi sử dụng nó bạn cần phải viết lệnh mở con trỏ, và viết lệnh đóng con trỏ sau khi đã sử dụng xong một cách rõ ràng. Với trường hợp con trỏ không tường minh bạn có thể không cần viết lệnh đóng mở. Declare -- Khai báo một Cursor có 2 tham số. Loop -- Lấy dòng dữ liệu trên Cursor -- Mỗi lần Fetch con trỏ nhẩy lên 1 dòng.

Sử dụng lệnh For để duyệt trên con trỏ theo cú pháp:. Một nhóm các lệnh thực hiện chức năng nào đó có thể được gom lại trong một thủ tục procedure nhằm làm tăng khả năng xử lý,khả năng sử dụng chung, tăng tính bảo mật và an toàn dữ liệu,tiện ích trong phát triển. Thủ tục có thể được lưu giữ ngay trong database như một đối tượng của database, sẵn sàng cho việc tái sử dụng. Thủ tục lúc này được gọi là Stored procedure. Với các thủ tục, ngay khi lưu giữ save , chúng đã được biên dịch thành dạng p-code vì thế có thể nâng cao khả năng thực hiện.

Begin -- Làm gì đó tại đây. End; -- Ví dụ một thủ tục có tham số -- Vừa tham số đầu vào, vừa tham số đầu ra. ví dụ này sẽ là khuôn mẫu giúp bạn vừa lập trình vừa kiểm tra lỗi nếu có vấn đề xẩy ra. Tuy nhiên bạn cần sửa lại danh sách tham số, và viết code cho thủ tục này.

Nhấn vào biểu tượng Execute hoặc F8 để biên dịch thủ tục. Giúp bạn dễ dàng tìm ra các vị trí phát sinh lỗi. Bạn có thể xem hướng dẫn tại:. Khác với thủ tục, các hàm sẽ trả về một giá trị ngay tại lời gọi của nó. Hàm cũng có thể được lưu giữ ngay trên database dưới dạng Stored procedure.

Với việc sử dụng hàm, trong một số trường hợp bạn có thể thấy được các lợi điểm như sau: Cho phép thực hiện các thao tác phức tạp các phép tìm kiếm, so sánh phứctạp ngay trong mệnh đề của câu lệnh SQL mà nếu không sử dụng hàm bạn sẽ không thể nào thực hiện được Tăng tính độc lập của dữ liệu do việc phân tích và xử lý dữ liệu được thực hiện ngay trên Server thay vì trả về dữ liệu trực tiếp cho ứng dụng dưới Client để chúng tiếp tục xử lý. Tăng tính hiệu quả của câu lệnh truy vấn bằng việc gọi các hàm ngay trong câu lệnh SQL Bạn có thể sử dụng hàm để thao tác trên các kiểu dữ liệu tự tạo.

Cho phép thực hiện đồng thời các câu lệnh truy vấn Một số hạn chế khi sử dụng hàm trong câu lệnh SQL Chỉ các hàm do người dùng định nghĩa được lưu trên database mới có thể sử dụng được cho câu lệnh SQL.

Các hàm do người dùng định nghĩa chỉ được áp dụng cho điều kiện thực hiện trên các dòng dữ liệu mệnh đề WHERE , không thể áp dụng cho các điều kiện thực hiện trên nhóm mệnh đề GROUP. Tham số sử dụng trong hàm chỉ có thể là loại IN, không chấp nhận giá trị OUT hay giá trị IN OUT.

Kiểu dữ liệu trả về của các hàm phải là kiểu dữ liệu DATE, NUMBER, NUMBER. Không cho phép hàm trả về kiểu dữ liệu như BOOLEAN, RECORD, TABLE. The handle method is invoked when the job is processed by the queue. Note that we are able to type-hint dependencies on the handle method of the job.

The Laravel service container automatically injects these dependencies. If you would like to take total control over how the container injects dependencies into the handle method, you may use the container's bindMethod method. The bindMethod method accepts a callback which receives the job and the container. Within the callback, you are free to invoke the handle method however you wish. Otherwise, the job may not properly serialize to JSON when being placed on the queue.

Because loaded relationships also get serialized, the serialized job string can sometimes become quite large. To prevent relations from being serialized, you can call the withoutRelations method on the model when setting a property value.

This method will return an instance of the model without its loaded relationships:. Furthermore, when a job is deserialized and model relationships are re-retrieved from the database, they will be retrieved in their entirety. Any previous relationship constraints that were applied before the model was serialized during the job queueing process will not be applied when the job is deserialized.

Therefore, if you wish to work with a subset of a given relationship, you should re-constrain that relationship within your queued job. Currently, the memcached , redis , dynamodb , database , file , and array cache drivers support atomic locks. In addition, unique job constraints do not apply to jobs within batches. Sometimes, you may want to ensure that only one instance of a specific job is on the queue at any point in time. You may do so by implementing the ShouldBeUnique interface on your job class.

This interface does not require you to define any additional methods on your class:. In the example above, the UpdateSearchIndex job is unique. So, the job will not be dispatched if another instance of the job is already on the queue and has not finished processing. In certain cases, you may want to define a specific "key" that makes the job unique or you may want to specify a timeout beyond which the job no longer stays unique. To accomplish this, you may define uniqueId and uniqueFor properties or methods on your job class:.

In the example above, the UpdateSearchIndex job is unique by a product ID. So, any new dispatches of the job with the same product ID will be ignored until the existing job has completed processing.

In addition, if the existing job is not processed within one hour, the unique lock will be released and another job with the same unique key can be dispatched to the queue. By default, unique jobs are "unlocked" after a job completes processing or fails all of its retry attempts. However, there may be situations where you would like your job to unlock immediately before it is processed. To accomplish this, your job should implement the ShouldBeUniqueUntilProcessing contract instead of the ShouldBeUnique contract:.

Behind the scenes, when a ShouldBeUnique job is dispatched, Laravel attempts to acquire a lock with the uniqueId key. If the lock is not acquired, the job is not dispatched.

This lock is released when the job completes processing or fails all of its retry attempts. By default, Laravel will use the default cache driver to obtain this lock. However, if you wish to use another driver for acquiring the lock, you may define a uniqueVia method that returns the cache driver that should be used:.

Job middleware allow you to wrap custom logic around the execution of queued jobs, reducing boilerplate in the jobs themselves. For example, consider the following handle method which leverages Laravel's Redis rate limiting features to allow only one job to process every five seconds:.

While this code is valid, the implementation of the handle method becomes noisy since it is cluttered with Redis rate limiting logic. In addition, this rate limiting logic must be duplicated for any other jobs that we want to rate limit.

Instead of rate limiting in the handle method, we could define a job middleware that handles rate limiting. Laravel does not have a default location for job middleware, so you are welcome to place job middleware anywhere in your application.

As you can see, like route middleware , job middleware receive the job being processed and a callback that should be invoked to continue processing the job. After creating job middleware, they may be attached to a job by returning them from the job's middleware method. This method does not exist on jobs scaffolded by the make:job Artisan command, so you will need to manually add it to your job class:.

Although we just demonstrated how to write your own rate limiting job middleware, Laravel actually includes a rate limiting middleware that you may utilize to rate limit jobs. Like route rate limiters , job rate limiters are defined using the RateLimiter facade's for method.

For example, you may wish to allow users to backup their data once per hour while imposing no such limit on premium customers. To accomplish this, you may define a RateLimiter in the boot method of your AppServiceProvider :. In the example above, we defined an hourly rate limit; however, you may easily define a rate limit based on minutes using the perMinute method.

In addition, you may pass any value you wish to the by method of the rate limit; however, this value is most often used to segment rate limits by customer:. Each time the job exceeds the rate limit, this middleware will release the job back to the queue with an appropriate delay based on the rate limit duration. Releasing a rate limited job back onto the queue will still increment the job's total number of attempts. You may wish to tune your tries and maxExceptions properties on your job class accordingly.

Or, you may wish to use the retryUntil method to define the amount of time until the job should no longer be attempted. If you do not want a job to be retried when it is rate limited, you may use the dontRelease method:. This can be helpful when a queued job is modifying a resource that should only be modified by one job at a time. For example, let's imagine you have a queued job that updates a user's credit score and you want to prevent credit score update job overlaps for the same user ID.

To accomplish this, you can return the WithoutOverlapping middleware from your job's middleware method:. Any overlapping jobs will be released back to the queue. You may also specify the number of seconds that must elapse before the released job will be attempted again:. If you wish to immediately delete any overlapping jobs so that they will not be retried, you may use the dontRelease method:. The WithoutOverlapping middleware is powered by Laravel's atomic lock feature.

Sometimes, your job may unexpectedly fail or timeout in such a way that the lock is not released. Therefore, you may explicitly define a lock expiration time using the expireAfter method. For example, the example below will instruct Laravel to release the WithoutOverlapping lock three minutes after the job has started processing:. Once the job throws a given number of exceptions, all further attempts to execute the job are delayed until a specified time interval lapses.

This middleware is particularly useful for jobs that interact with third-party services that are unstable. For example, let's imagine a queued job that interacts with a third-party API that begins throwing exceptions.

To throttle exceptions, you can return the ThrottlesExceptions middleware from your job's middleware method. Typically, this middleware should be paired with a job that implements time based attempts :. The first constructor argument accepted by the middleware is the number of exceptions the job can throw before being throttled, while the second constructor argument is the number of minutes that should elapse before the job is attempted again once it has been throttled.

In the code example above, if the job throws 10 exceptions within 5 minutes, we will wait 5 minutes before attempting the job again. When a job throws an exception but the exception threshold has not yet been reached, the job will typically be retried immediately. However, you may specify the number of minutes such a job should be delayed by calling the backoff method when attaching the middleware to the job:.

Internally, this middleware uses Laravel's cache system to implement rate limiting, and the job's class name is utilized as the cache "key". You may override this key by calling the by method when attaching the middleware to your job. This may be useful if you have multiple jobs interacting with the same third-party service and you would like them to share a common throttling "bucket":.

Once you have written your job class, you may dispatch it using the dispatch method on the job itself. The arguments passed to the dispatch method will be given to the job's constructor:. If you would like to conditionally dispatch a job, you may use the dispatchIf and dispatchUnless methods:.

If you would like to specify that a job should not be immediately available for processing by a queue worker, you may use the delay method when dispatching the job. For example, let's specify that a job should not be available for processing until 10 minutes after it has been dispatched:.

Alternatively, the dispatchAfterResponse method delays dispatching a job until after the HTTP response is sent to the user's browser. This will still allow the user to begin using the application even though a queued job is still executing.

This should typically only be used for jobs that take about a second, such as sending an email. Since they are processed within the current HTTP request, jobs dispatched in this fashion do not require a queue worker to be running in order for them to be processed:. You may also dispatch a closure and chain the afterResponse method onto the dispatch helper to execute a closure after the HTTP response has been sent to the browser:. If you would like to dispatch a job immediately synchronously , you may use the dispatchSync method.

When using this method, the job will not be queued and will be executed immediately within the current process:. While it is perfectly fine to dispatch jobs within database transactions, you should take special care to ensure that your job will actually be able to execute successfully.

When dispatching a job within a transaction, it is possible that the job will be processed by a worker before the transaction has committed. When this happens, any updates you have made to models or database records during the database transaction may not yet be reflected in the database. In addition, any models or database records created within the transaction may not exist in the database. Thankfully, Laravel provides several methods of working around this problem. Of course, if no database transactions are currently open, the job will be dispatched immediately.

If a transaction is rolled back due to an exception that occurs during the transaction, the dispatched jobs that were dispatched during that transaction will be discarded. To accomplish this, you may chain the afterCommit method onto your dispatch operation:. Job chaining allows you to specify a list of queued jobs that should be run in sequence after the primary job has executed successfully. If one job in the sequence fails, the rest of the jobs will not be run. To execute a queued job chain, you may use the chain method provided by the Bus facade.

Laravel's command bus is a lower level component that queued job dispatching is built on top of:. The chain will only stop executing if a job in the chain fails. If you would like to specify the connection and queue that should be used for the chained jobs, you may use the onConnection and onQueue methods. When chaining jobs, you may use the catch method to specify a closure that should be invoked if a job within the chain fails. The given callback will receive the Throwable instance that caused the job failure:.

By pushing jobs to different queues, you may "categorize" your queued jobs and even prioritize how many workers you assign to various queues. Keep in mind, this does not push jobs to different queue "connections" as defined by your queue configuration file, but only to specific queues within a single connection.

To specify the queue, use the onQueue method when dispatching the job:. Alternatively, you may specify the job's queue by calling the onQueue method within the job's constructor:.

If your application interacts with multiple queue connections, you may specify which connection to push a job to using the onConnection method:. You may chain the onConnection and onQueue methods together to specify the connection and the queue for a job:.

Alternatively, you may specify the job's connection by calling the onConnection method within the job's constructor:. If one of your queued jobs is encountering an error, you likely do not want it to keep retrying indefinitely. Therefore, Laravel provides various ways to specify how many times or for how long a job may be attempted. One approach to specifying the maximum number of times a job may be attempted is via the --tries switch on the Artisan command line. This will apply to all jobs processed by the worker unless the job being processed specifies a more specific number of times it may be attempted:.

If a job exceeds its maximum number of attempts, it will be considered a "failed" job. For more information on handling failed jobs, consult the failed job documentation. You may take a more granular approach by defining the maximum number of times a job may be attempted on the job class itself.

If the maximum number of attempts is specified on the job, it will take precedence over the --tries value provided on the command line:. As an alternative to defining how many times a job may be attempted before it fails, you may define a time at which the job should no longer be attempted. This allows a job to be attempted any number of times within a given time frame. To define the time at which a job should no longer be attempted, add a retryUntil method to your job class.

This method should return a DateTime instance:. Sometimes you may wish to specify that a job may be attempted many times, but should fail if the retries are triggered by a given number of unhandled exceptions as opposed to being released by the release method directly.

To accomplish this, you may define a maxExceptions property on your job class:. In this example, the job is released for ten seconds if the application is unable to obtain a Redis lock and will continue to be retried up to 25 times.

However, the job will fail if three unhandled exceptions are thrown by the job. Often, you know roughly how long you expect your queued jobs to take. For this reason, Laravel allows you to specify a "timeout" value. If a job is processing for longer than the number of seconds specified by the timeout value, the worker processing the job will exit with an error.

Typically, the worker will be restarted automatically by a process manager configured on your server. The maximum number of seconds that jobs can run may be specified using the --timeout switch on the Artisan command line:.

You may also define the maximum number of seconds a job should be allowed to run on the job class itself. If the timeout is specified on the job, it will take precedence over any timeout specified on the command line:.

Sometimes, IO blocking processes such as sockets or outgoing HTTP connections may not respect your specified timeout. Therefore, when using these features, you should always attempt to specify a timeout using their APIs as well. For example, when using Guzzle, you should always specify a connection and request timeout value. If an exception is thrown while the job is being processed, the job will automatically be released back onto the queue so it may be attempted again.

The job will continue to be released until it has been attempted the maximum number of times allowed by your application. The maximum number of attempts is defined by the --tries switch used on the queue:work Artisan command. Alternatively, the maximum number of attempts may be defined on the job class itself. More information on running the queue worker can be found below. Sometimes you may wish to manually release a job back onto the queue so that it can be attempted again at a later time.

You may accomplish this by calling the release method:. By default, the release method will release the job back onto the queue for immediate processing. However, by passing an integer to the release method you may instruct the queue to not make the job available for processing until a given number of seconds has elapsed:.

Occasionally you may need to manually mark a job as "failed". To do so, you may call the fail method:. If you would like to mark your job as failed because of an exception that you have caught, you may pass the exception to the fail method:.

Laravel's job batching feature allows you to easily execute a batch of jobs and then perform some action when the batch of jobs has completed executing.

Before getting started, you should create a database migration to build a table to contain meta information about your job batches, such as their completion percentage. This migration may be generated using the queue:batches-table Artisan command:. This trait provides access to a batch method which may be used to retrieve the current batch that the job is executing within:.

To dispatch a batch of jobs, you should use the batch method of the Bus facade. Of course, batching is primarily useful when combined with completion callbacks. So, you may use the then , catch , and finally methods to define completion callbacks for the batch.

In this example, we will imagine we are queueing a batch of jobs that each process a given number of rows from a CSV file:. Some tools such as Laravel Horizon and Laravel Telescope may provide more user-friendly debug information for batches if batches are named.

To assign an arbitrary name to a batch, you may call the name method while defining the batch:. If you would like to specify the connection and queue that should be used for the batched jobs, you may use the onConnection and onQueue methods. All batched jobs must execute within the same connection and queue:. You may define a set of chained jobs within a batch by placing the chained jobs within an array.

For example, we may execute two job chains in parallel and execute a callback when both job chains have finished processing:.

Sometimes it may be useful to add additional jobs to a batch from within a batched job. This pattern can be useful when you need to batch thousands of jobs which may take too long to dispatch during a web request.

So, instead, you may wish to dispatch an initial batch of "loader" jobs that hydrate the batch with even more jobs:. In this example, we will use the LoadImportBatch job to hydrate the batch with additional jobs. To accomplish this, we may use the add method on the batch instance that may be accessed via the job's batch method:.

This makes it convenient to display information about the batch's completion progress in your application's UI. To retrieve a batch by its ID, you may use the Bus facade's findBatch method:. Sometimes you may need to cancel a given batch's execution. As you may have noticed in previous examples, batched jobs should typically check to see if the batch has been cancelled at the beginning of their handle method:.

When a batched job fails, the catch callback if assigned will be invoked. This callback is only invoked for the first job that fails within the batch. When a job within a batch fails, Laravel will automatically mark the batch as "cancelled". If you wish, you may disable this behavior so that a job failure does not automatically mark the batch as cancelled.

This may be accomplished by calling the allowFailures method while dispatching the batch:. For convenience, Laravel provides a queue:retry-batch Artisan command that allows you to easily retry all of the failed jobs for a given batch. The queue:retry-batch command accepts the UUID of the batch whose failed jobs should be retried:. To mitigate this, you should schedule the queue:prune-batches Artisan command to run daily:.

By default, all finished batches that are more than 24 hours old will be pruned. You may use the hours option when calling the command to determine how long to retain batch data.

For example, the following command will delete all batches that finished over 48 hours ago:. You may instruct the queue:prune-batches command to prune these unfinished batch records using the unfinished option:. Instead of dispatching a job class to the queue, you may also dispatch a closure. This is great for quick, simple tasks that need to be executed outside of the current request cycle.

When dispatching closures to the queue, the closure's code content is cryptographically signed so that it can not be modified in transit:. Using the catch method, you may provide a closure that should be executed if the queued closure fails to complete successfully after exhausting all of your queue's configured retry attempts :. Laravel includes an Artisan command that will start a queue worker and process new jobs as they are pushed onto the queue.

You may run the worker using the queue:work Artisan command. Note that once the queue:work command has started, it will continue to run until it is manually stopped or you close your terminal:. Remember, queue workers, are long-lived processes and store the booted application state in memory.

As a result, they will not notice changes in your code base after they have been started. So, during your deployment process, be sure to restart your queue workers. In addition, remember that any static state created or modified by your application will not be automatically reset between jobs. Alternatively, you may run the queue:listen command. When using the queue:listen command, you don't have to manually restart the worker when you want to reload your updated code or reset the application state; however, this command is significantly less efficient than the queue:work command:.

To assign multiple workers to a queue and process jobs concurrently, you should simply start multiple queue:work processes. This can either be done locally via multiple tabs in your terminal or in production using your process manager's configuration settings.

When using Supervisor , you may use the numprocs configuration value. You may also specify which queue connection the worker should utilize. php configuration file:. By default, the queue:work command only processes jobs for the default queue on a given connection.

However, you may customize your queue worker even further by only processing particular queues for a given connection. For example, if all of your emails are processed in an emails queue on your redis queue connection, you may issue the following command to start a worker that only processes that queue:.

The --once option may be used to instruct the worker to only process a single job from the queue:. The --max-jobs option may be used to instruct the worker to process the given number of jobs and then exit. This option may be useful when combined with Supervisor so that your workers are automatically restarted after processing a given number of jobs, releasing any memory they may have accumulated:. The --stop-when-empty option may be used to instruct the worker to process all jobs and then exit gracefully.

This option can be useful when processing Laravel queues within a Docker container if you wish to shutdown the container after the queue is empty:.

WARNING You're browsing the documentation for an old version of Laravel. Consider upgrading your project to Laravel 9. While building your web application, you may have some tasks, such as parsing and storing an uploaded CSV file, that take too long to perform during a typical web request.

Thankfully, Laravel allows you to easily create queued jobs that may be processed in the background. By moving time intensive tasks to a queue, your application can respond to web requests with blazing speed and provide a better user experience to your customers.

Laravel queues provide a unified queueing API across a variety of different queue backends, such as Amazon SQS , Redis , or even a relational database. php configuration file.

In this file, you will find connection configurations for each of the queue drivers that are included with the framework, including the database, Amazon SQS , Redis , and Beanstalkd drivers, as well as a synchronous driver that will execute jobs immediately for use during local development. A null queue driver is also included which discards queued jobs. Check out the full Horizon documentation for more information. Before getting started with Laravel queues, it is important to understand the distinction between "connections" and "queues".

php configuration file, there is a connections configuration array. This option defines the connections to backend queue services such as Amazon SQS, Beanstalk, or Redis. However, any given queue connection may have multiple "queues" which may be thought of as different stacks or piles of queued jobs. Note that each connection configuration example in the queue configuration file contains a queue attribute.

This is the default queue that jobs will be dispatched to when they are sent to a given connection. In other words, if you dispatch a job without explicitly defining which queue it should be dispatched to, the job will be placed on the queue that is defined in the queue attribute of the connection configuration:. Some applications may not need to ever push jobs onto multiple queues, instead preferring to have one simple queue.

However, pushing jobs to multiple queues can be especially useful for applications that wish to prioritize or segment how jobs are processed, since the Laravel queue worker allows you to specify which queues it should process by priority. For example, if you push jobs to a high queue, you may run a worker that gives them higher processing priority:.

In order to use the database queue driver, you will need a database table to hold the jobs. To generate a migration that creates this table, run the queue:table Artisan command. Once the migration has been created, you may migrate your database using the migrate command:. env file:. If your Redis queue connection uses a Redis Cluster, your queue names must contain a key hash tag. This is required in order to ensure all of the Redis keys for a given queue are placed into the same hash slot:.

Adjusting this value based on your queue load can be more efficient than continually polling the Redis database for new jobs. For instance, you may set the value to 5 to indicate that the driver should block for five seconds while waiting for a job to become available:. This will also prevent signals such as SIGTERM from being handled until the next job has been processed.

The following dependencies are needed for the listed queue drivers. These dependencies may be installed via the Composer package manager:. Job classes are very simple, normally containing only a handle method that is invoked when the job is processed by the queue. To get started, let's take a look at an example job class. In this example, we'll pretend we manage a podcast publishing service and need to process the uploaded podcast files before they are published:.

In this example, note that we were able to pass an Eloquent model directly into the queued job's constructor. Because of the SerializesModels trait that the job is using, Eloquent models and their loaded relationships will be gracefully serialized and unserialized when the job is processing. If your queued job accepts an Eloquent model in its constructor, only the identifier for the model will be serialized onto the queue.

When the job is actually handled, the queue system will automatically re-retrieve the full model instance and its loaded relationships from the database. This approach to model serialization allows for much smaller job payloads to be sent to your queue driver.

The handle method is invoked when the job is processed by the queue. Note that we are able to type-hint dependencies on the handle method of the job. The Laravel service container automatically injects these dependencies. If you would like to take total control over how the container injects dependencies into the handle method, you may use the container's bindMethod method.

The bindMethod method accepts a callback which receives the job and the container. Within the callback, you are free to invoke the handle method however you wish. Otherwise, the job may not properly serialize to JSON when being placed on the queue.

Because loaded relationships also get serialized, the serialized job string can sometimes become quite large. To prevent relations from being serialized, you can call the withoutRelations method on the model when setting a property value. This method will return an instance of the model without its loaded relationships:.

Furthermore, when a job is deserialized and model relationships are re-retrieved from the database, they will be retrieved in their entirety. Any previous relationship constraints that were applied before the model was serialized during the job queueing process will not be applied when the job is deserialized. Therefore, if you wish to work with a subset of a given relationship, you should re-constrain that relationship within your queued job.

Currently, the memcached , redis , dynamodb , database , file , and array cache drivers support atomic locks. In addition, unique job constraints do not apply to jobs within batches. Sometimes, you may want to ensure that only one instance of a specific job is on the queue at any point in time. You may do so by implementing the ShouldBeUnique interface on your job class.

This interface does not require you to define any additional methods on your class:. In the example above, the UpdateSearchIndex job is unique. So, the job will not be dispatched if another instance of the job is already on the queue and has not finished processing.

In certain cases, you may want to define a specific "key" that makes the job unique or you may want to specify a timeout beyond which the job no longer stays unique. To accomplish this, you may define uniqueId and uniqueFor properties or methods on your job class:. In the example above, the UpdateSearchIndex job is unique by a product ID. So, any new dispatches of the job with the same product ID will be ignored until the existing job has completed processing. In addition, if the existing job is not processed within one hour, the unique lock will be released and another job with the same unique key can be dispatched to the queue.

By default, unique jobs are "unlocked" after a job completes processing or fails all of its retry attempts. However, there may be situations where you would like your job to unlock immediately before it is processed. To accomplish this, your job should implement the ShouldBeUniqueUntilProcessing contract instead of the ShouldBeUnique contract:. Behind the scenes, when a ShouldBeUnique job is dispatched, Laravel attempts to acquire a lock with the uniqueId key.

If the lock is not acquired, the job is not dispatched. This lock is released when the job completes processing or fails all of its retry attempts. By default, Laravel will use the default cache driver to obtain this lock. However, if you wish to use another driver for acquiring the lock, you may define a uniqueVia method that returns the cache driver that should be used:. Job middleware allow you to wrap custom logic around the execution of queued jobs, reducing boilerplate in the jobs themselves.

For example, consider the following handle method which leverages Laravel's Redis rate limiting features to allow only one job to process every five seconds:. While this code is valid, the implementation of the handle method becomes noisy since it is cluttered with Redis rate limiting logic. In addition, this rate limiting logic must be duplicated for any other jobs that we want to rate limit.

Instead of rate limiting in the handle method, we could define a job middleware that handles rate limiting. Laravel does not have a default location for job middleware, so you are welcome to place job middleware anywhere in your application. As you can see, like route middleware , job middleware receive the job being processed and a callback that should be invoked to continue processing the job.

After creating job middleware, they may be attached to a job by returning them from the job's middleware method. This method does not exist on jobs scaffolded by the make:job Artisan command, so you will need to manually add it to your job class:. Although we just demonstrated how to write your own rate limiting job middleware, Laravel actually includes a rate limiting middleware that you may utilize to rate limit jobs.

Like route rate limiters , job rate limiters are defined using the RateLimiter facade's for method. For example, you may wish to allow users to backup their data once per hour while imposing no such limit on premium customers. To accomplish this, you may define a RateLimiter in the boot method of your AppServiceProvider :. In the example above, we defined an hourly rate limit; however, you may easily define a rate limit based on minutes using the perMinute method.

In addition, you may pass any value you wish to the by method of the rate limit; however, this value is most often used to segment rate limits by customer:. Each time the job exceeds the rate limit, this middleware will release the job back to the queue with an appropriate delay based on the rate limit duration. Releasing a rate limited job back onto the queue will still increment the job's total number of attempts.

You may wish to tune your tries and maxExceptions properties on your job class accordingly. Or, you may wish to use the retryUntil method to define the amount of time until the job should no longer be attempted. If you do not want a job to be retried when it is rate limited, you may use the dontRelease method:. This can be helpful when a queued job is modifying a resource that should only be modified by one job at a time.

For example, let's imagine you have a queued job that updates a user's credit score and you want to prevent credit score update job overlaps for the same user ID.

To accomplish this, you can return the WithoutOverlapping middleware from your job's middleware method:. Any overlapping jobs will be released back to the queue. You may also specify the number of seconds that must elapse before the released job will be attempted again:.

If you wish to immediately delete any overlapping jobs so that they will not be retried, you may use the dontRelease method:.

The WithoutOverlapping middleware is powered by Laravel's atomic lock feature.

Its truth value is false. pkg về cài đặt lại. Các cá nhân không tiếp xúc cơ thể dẫn đến hưng phấn về tình dục hoặc cực khoái và cũng không có phản ứng tâm lý đối với các cá nhân cùng giới tính với họ. drawString 0, 18, String priceUSD ; display. To get started, let's take a look at an example job class. Git - Trình quản lý phiên bản sử dụng rất rộng rãi trên thế giới, Github là một mạng xã hội cho lập trình viên dựa trên Git. Nó chỉ có thể được sử dụng trong nội bộ hàm hay thủ tục đó.

Categories:

• Forex
• Binary Options online
• Forex Brokers
• Forex Bitcoin
• Binary Options