South America Phone Number Database

Blog

South America  Phone Number database

One thing to keep in mind when creating an event handler to create a saga orchestrator is that it has to manage multiple events. A message delivered at least once means that an event handler which creates the saga could be called several times. It’s crucial to make sure that only one instance of the saga is created. buy South America  Phone Number database

One approach is to deduce an ID of the saga by identifying one particular characteristic of the particular event. There are many possible options. One option is to utilize the aggre-gate’s ID that generates the event to be the saga’s ID. This is ideal for sagas created as a result of global creation events.

Another alternative is to use the event ID to create the saga ID. Since the event IDs are unique it is guaranteed that the saga ID will be unique. If the event is duplicated that is, the event han-dler’s effort in creating the saga won’t succeed due to the fact that it is likely that the ID has already been created. This is a good option in situations where multiple versions of the same story be found for an overall instance. South America  Phone Number Profile

An application that makes use of an event store that is based on RDBMS can make use of the same approach to make stories. One benefit of this strategy is that it encourages loose coupling since services like OrderService are no longer required to explicitly initiate stories.

We’ve now looked at how to create a reliable orchestrator for a saga, let’s look at the ways that event sourcing services can take part in orchestration-based stories. South America  Phone Number Profile

Implementing an event-based saga that is sourced participant South America  Phone Number database

Imagine you are using event sourcing to build an application that has to be part of the orchestration of a saga. This isn’t a surprise, especially when your service is using an event store that is based on RDBMS, like Eventuate Local, you can easily make sure that it processes commands from saga and also responds. It’s possible to update the store as part of an ACID transaction that is initiated through the Eventuate Tram framework. However, you’ll need an entirely different method when your service utilizes an existing event database that doesn’t be part of similar transactions as Eventuate Tram framework.

You need to address two problems:

Command message handling that is independant

Sending a message in a jiffy

Let’s look at the first step in how to implement idempotent command messages handlers.

IDEMPOTENT COMMAND MESSAGE HANDLE

The first issue to resolve is how an event-sourcing-based program can recognize and eliminate duplicate messages to implement idempotent command messages handling. It is a fortunately easy issue to tackle with the mes-sage handling mechanism that we discussed earlier. The saga participant keeps the message ID in events that occur when handling the messages. Prior to updating an aggregate, the saga player confirms that it didn’t process the message prior to checking for the message ID within the events. South America  Phone Number Profile

Atmically sending out Reply MeSSAGES

The other issue to be solved is how an event-sourcing-based player in saga can simultaneously send responses. In theory the saga orchestrator can join the events that are generated by aggregates, however there are two issues that arise with this method. The second issue is the fact that a saga request may not alter the status of an aggregate. In this scenario it is not possible for the aggregate to produce an event, and there won’t be a response to the saga orchestrator. Another issue is that this strategy will require the saga orchestrator be able to treat saga participants who utilize event sourcing in a different way from those who do not. In order to be able to receive events from domains the saga orchestrator needs to sign up to the aggregate’s events channel, in along with its own response channel. South America  Phone Number database

An alternative is for the participant to continue sending an answer message to the saga orchestrator’s replies channel. However, rather than sending the reply directly, a saga player follows a two-step procedure: When an saga command handler is able to create and/or updates an aggregate it organizes for an SagaReplyRequested pseudo-event to be saved to the event store , along with the actual events generated through the aggregate.

The event handler that handles the SagaReplyRequested pseudo-event utilizes the information contained in the event to build the reply message. sends to the Saga orchestrator’s response channel.

Let’s take a look at an example to show how it is done.

Example of an event that is sourced from the internet. SAGA Participant South America  Phone Number leads

This instance focuses on Accounting Service, one of the players in Create Order Saga. Figure 6.12 illustrates the way Accounting Service handles the Authorize Command issued by the Saga. Accounting Service is implemented using the Eventuate Saga frame-work. Its Eventuate Saga framework is an open-source framework that allows you to write stories that make use of event source. It is based around the Eventuate Client framework.
Create Order Saga sends an AuthorizeAccount command to Accounting-Service through a messaging channel. The Eventuate Saga framework’s SagaCommand-Dispatcher invokes AccountingServiceCommandHandler to handle the command message. buy South America  Phone Number database

AccountingServiceCommandHandler sends the command to the specified

South America  Phone Number mailing lists

Account aggregate.

The aggregate emits two events, AccountAuthorized and SagaReplyRequested-Event.

SagaReplyRequestedEventHandler handles SagaReplyRequestedEvent by send-ing a reply message to CreateOrderSaga. South America  Phone Number id list

The AccountingServiceCommandHandler shown in the following listing handles the AuthorizeAccount command message by calling AggregateRepository.update() to update the Account aggregate.

The listing 6.6 Handles command messages sent by Sagas South America  Phone Number database

public class AccountingServiceCommandHandler {

Private AggregateRepository accountRepository;

public void authorize(CommandMessage cm) { AuthorizeCommand command = cm.getCommand(); accountRepository.update(command.getOrderId(), South America  Phone Number leads

command,

replyingTo(cm)

.catching(AccountDisabledException.class,

() -> withFailure(new AccountDisabledReply()))

.build());

}

…

This authorize() method is invoked by an AggregateRepository to modify the aggregate for the Account. The third argument for updating() the UpdateOptions, also known as the UpdateOptions parameter, is calculated by using the following expression: South America  Phone Number leads

replyingTo(cm)

.catching(AccountDisabledException.class,

() -> withFailure(new AccountDisabledReply()))

.build()

The UpdateOptions are used to configure this Update() procedure to accomplish these things:

Utilize the message ID as an idempotency key in order to make sure that the information is processed precisely once. As previously mentioned that the Eventuate framework stores the idempotency keys in all events generated, allowing it to recognize and block duplicate attempts to update the aggregate. South America  Phone Number database

Add a SagaReplyRequestedEvent pseudo event to the list of events saved in the event store. When SagaReplyRequestedEventHandler receives the SagaReply-RequestedEvent pseudo event, it sends a reply to the CreateOrderSaga’s reply channel.

Send an AccountDisabledReply instead of the default error reply when the aggregate throws an AccountDisabledException.

We’ve now looked at the ways to incorporate the saga participant using event-sourcing Let’s look at how to set up Saga orchestrators.

Implementing saga orchestrators by using event source

In this section I’ve explained how services based on event sourcing can start and take part in the sagas. Additionally, you can utilize event sourcing for the development of orches-trators for sagas. This allows you to create applications dependent upon an event-based store. South America  Phone Number leads

There are three major design issues you need to solve when you implement an orchestrator for saga:

How do you keep the orchestrator of a saga?

How can you change what happens to the orchestrator’s status and also send com-mand messages?

How do you make sure that the Saga orchestrator is able to process reply messages only at the same time? South America  Phone Number database

CONTINUING A SAGA ORCHESTRATOR WHILE WORKING WITH EVENT SOURCING

The saga orchestrator is an extremely straightforward life cycle. First, it’s created. It’s updated in response to the responses of saga participants. So, we could keep a saga going by the following scenarios:

SagaOrchestratorCreated–The saga orchestrator has been created.

SagaOrchestratorUpdated–The saga orchestrator has been updated.

A saga orchestrator emits a SagaOrchestratorCreated event when it’s created and a SagaOrchestratorUpdated event when it has been updated. These events contain information required to recreate an instance of state for the orchestrator in saga. For example, the events for CreateOrderSaga, described in chapter 4, would contain a serialized (for example, JSON) CreateOrderSagaState. buy South America  Phone Number database

South America  Phone Number lists

SENDING COMMAND MESSAGES RELIABLELY

Another crucial design challenge is how to continuously change the state of the saga , and issue an instruction. In chapter 4of the book, the Eventuate Tram-based saga implementation achieves this by updating the orchestrator and putting messages from commands in a table of messages in that same process. A program that utilizes an event store that is based on RDBMS, like Eventuate Local is able to use the same technique. A program that utilizes an event store based on NoSQL like Eventuate SaaS, can use similar methods however, it does have a restricted transaction model. South America  Phone Number id list

It is important to keep the SagaCommandEvent that represents the command to send. A handler for events then connects to SagaCommandEvents and then sends every command message to the appropriate channel. Figure 6.13 illustrates how this is done.

The saga orchestrator utilizes two steps to transmit commands: South America  Phone Number leads

A saga orchestrator generates an SagaCommandEvent for every command it intends to send. SagaCommandEvent includes all the information required to send the command like the destination channel, as well as an object for the command. These events are saved in the event storage.

An event handler handles these SagaCommandEvents and transmits commands to the message channel that is intended for destination. South America  Phone Number database

This two-step method ensures it will only be delivered to at minimum once. Since the event store allows at-least-once delivery, an handler could be

repeated multiple times using identical events. This causes the event handler of SagaCommandEvents to send multiple commands. Luckily, however Saga participants can quickly identify and eliminate duplicate commands by using the following procedure. This ID, which is unique to SagaCommandEvent which is proven that it is unique to determine the ID for each command. Therefore, duplicate messages will be assigned the identical ID. The saga participant who is notified of a duplicate can discard it with the method described previously. South America  Phone Number listing

PROCESSING REPLIES exactly as they were sent

The saga orchestrator must also be able to be able to recognize and remove duplicate replies. This it is possible to do by through the process described earlier. The orchestrator records the ID of the reply message in the events it generates during processing the response. It is then able to easily determine whether the message is a duplicate.

As you can observe, event sourcing provides an excellent foundation to implement stories. This is in addition to additional benefits of using event sourcing, such as the inherent reliability of the production of events every time data changes, accurate audit logs, as well as the ability to run temporal queries. Event sourcing isn’t a magic solution, however. It requires a substantial learning curve. It’s not always simple. Yet, despite these shortcomings events sourcing plays an important role to play in a micro-services architecture. In the next chapter, we’ll shift to a different topic and explore ways to address a different problem with distributed data management within a microservices architecture that is queries. I’ll show you the steps to implement queries to retrieve data distributed across several services.

Event sourcing remains an aggregate of events. Each event has a negative reaction to either the making of the aggregate, or a change in its state. A program creates the state of the aggregate by replaying events. Event sourcing records the history of an object in a domain, and provides an audit trail that is accurate and consistently publishes domain-specific events. South America  Phone Number listing

Snapshots boost efficiency by reducing the amount of events that have to be replayed.

Events are saved inside an events store. It is a hybrid between an event store and a message broker. If an event is saved by a service from an online store it will deliver the event to the subscribers.

Eventsuate Local is an open-source event store that is based in MySQL along with Apache Kafka. Developers make use of this Eventuate Client Framework to write event handlers and aggregates. South America  Phone Number database

One of the challenges with event sourcing is dealing with the changing nature of events. The application could have to deal with multiple versions of an event in replaying the events. The best solution is to use upcasting that upgrades events to the most recent version each time they’re downloaded by the events store. South America  Phone Number listing

Eliminating data from an application for event sourcing is a challenge. A program must employ methods like encryption and pseudonymization to meet the requirements of regulations such as the GDPR of the European Union that require an application to erase the personal data of an individual.

Event sourcing is an easy method to create sagas based on choreography. Ser-vices include event handlers which take note of events announced by aggregates that use event sourcing. South America  Phone Number database

Mary as well as her colleagues were just beginning to become comfortable with the concept of using sagas in order to ensure the consistency of data. They realized that transactions management wasn’t the only distributed data challenge they were faced with while transferring to the FTGO app to microservices. Additionally, they needed to determine the best way to make queries work.
To support the UI to support the UI, to support the UI, FTGO application makes use of a variety of queries. Implementing these queries within the monolithic application is fairly simple, since it uses one database. The majority of the time all FTGO developers had to write was SQL SELECT commands and create the indexes needed. As Mary discovered the process of writing queries in micro-services isn’t easy. They often require data that’s scattered across databases that are owned by various services. However, you can’t make use of traditional distributed query mechanisms however, even if it was technically feasible the method would violate the principle of encapsulation. buy South America  Phone Number database

South America  Phone Number

Think about, for instance the operations that query the FTGO application that is discussed in chapter 2. Some queries retrieve information that’s only owned by one particular service. The find-ConsumerProfile() query, for example, returns data from Consumer Service. However, other FTGO queries such as locateOrder() or findOrderHistory() provide information from multiple services. Implementing these operations isn’t as simple. South America  Phone Number id list

There are two distinct methods of implementing queries in a microser-vice architecture:

The API composition pattern is the most straightforward method and should be employed whenever it is possible. It is a method of making the those who have the data responsible for calling the API and then combining the results. South America  Phone Number database

It is the Command queries accountability segregation (CQRS) pattern is more powerful over that of the API composition patterns, however it’s also more complicated. It is responsible for at least one view database that’s sole function is to help support queries. South America  Phone Number database

After examining both of these patterns I’ll explain how to design CQRS views, aided by the creation of an instance view. We will begin by looking at the API composition pattern.

Utilizing the API composition pattern to query. API composition pattern

The FTGO application is able to perform a variety of queries. Certain queries, as I mentioned earlier, pull data from one service. Implementing these queries is usually straightforward–although later in this chapter, when I cover the CQRS pat-tern, you’ll see examples of single service queries that are challenging to implement.

There are queries that fetch information from multiple services. In this article I will describe how to use the FindOrder() query as one example that pulls data from several services. I discuss the issues that arise when using this kind of query within microservices. I also explain what I call the API structure and explain how to use it to build queries like FindOrder(). South America  Phone Number database

The FindOrder() search operation

This findOrder() operation returns an order based on it’s primary key. It accepts an orderId as parameter and returns an OrderDetails object which includes information concerning the particular order. In the figure 7.1 the operation is performed by a frontend module for example, mobile devices or a web application, which implements the View of Order Status. South America  Phone Number database

The information shown by the order Status view provides essential information regarding the order, such as the status of the order, its payment status and the status of the order from the restaurant’s point of view as well as the delivery status as well as its location and estimated delivery time if it is the order is in transit.

Because the information is contained in one database, it is a monolithic FTGO application is able to quickly retrieve the details of orders by using an SELECT query that connects the various tables. However in the microservices-based version of the FTGO application, the information is dispersed across various services. South America  Phone Number database

Order Service–Basic information about the order including the order details, as well as status

Kitchen Service – Status of the order from the perspective of the restaurant and the estimated date it will be ready to pick up

Delivery Service – The order’s delivery status as well as estimated delivery information and the current address

Accounting Service – The order’s payment status South America  Phone Number

Anyone who requires details of the order must inquire about for all of these services. South America  Phone Number database

An overview of the API composition pattern. API composition pattern

One method to implement queries, like findOrder() to retrieve data that is owned by multiple services is by using the API composition pattern. This pattern executes the query operation by calling the service that holds the data, and then mixing the results.

API composer API composer performs the query by obtaining information from the service providers and combining the results. A com-poser API could be an endpoint, for example, an application for the web, which requires data in order to render an online page. It could also be the case of a service, like an API gateway or its Backends for Frontends version, as described in chapter 8 that makes the query operation available by way of the API endpoint. email marketing database South America  Phone Number

South America  Phone Number listing

If you are able to use this method to implement an operation that you require depends on a number of variables, such as the way the data is divided and the capabilities of the APIs offered by the services that host the data in addition to the capacities of databases that are used in the process. For instance, even though the Provider services provide APIs to retrieve the needed details, the aggregater could require an inefficient, memory-based joining of huge data sets. In the future, you’ll find examples of query functions which aren’t possible to implement with this method. There are many situations where this pattern can be used. For a look at it in action we’ll take a look at an illustration. South America  Phone Number id list

Utilizing the FindOrder() search operation by using an API composition pattern

FindOrder() search operation is equivalent to a primary key-based equijoin query. It is reasonable to assume that every Provider service includes an API end-point to retrieve the data required using orderId. Thus using the FindOrder() query function is a great possibility to implement API composer. API composer pattern. The API composer makes use of the four services and then combines the results. Figure 7.3 illustrates the layout for Find Order Composer. Find Order Composer. South America  Phone Number database

In this case it is API composer is API composer can be described as a service that provides the query as an REST-based endpoint. The Provider services also provide REST APIs. The concept is same regardless of whether the provider uses an communications protocol for interprocess, like gRPC rather than HTTP. This Find Order Composer implements a REST endpoint called GET/order/orderId. It invokes four service and joins the results by using the orderId. Each Provider service implements a REST API endpoint that produces a response in line with one aggregate. The OrderService is able to retrieve its own version of an order using its primary key, while the other services utilize an orderId key as a secondary key in order to find their aggregates.

As you can observe it, as you can see, the API structure pattern can be easy to follow. Let’s take a look at some of the design concerns that you need to address when using this pattern. South America  Phone Number

API composition design issues

If you are using this pattern, you need to consider some design concerns:

The decision of which component of your structure is your API query composer

How do I write an effective algorithmic aggregation logic?

Let’s take a look at each aspect. South America  Phone Number database

Who is the person who plays the role of the API COOSER?

The first decision you need to decide is who will play the function for the operation’s API composer. There are three choices available to you.

A frontend application, such as a web-based application that incorporates an Order Status view and runs on the same network, can efficiently access the order information with this method. However, as you’ll see in Chapter 8, this approach isn’t a good idea for customers who are not part of the firewall and are able to access services through the slower network.

The other option, as illustrated in figure 7.5 is an API gateway that uses the external API of the program to implement the API and plays the function as an API composer to perform a query.

This choice is appropriate in the event that the query is part of an application’s API external to it. Instead of routing the request to a different service that is not an API gateway, the API gateway uses the API composition process. This allows a client like mobile devices, operating outside the firewall to quickly get data from multiple services through one API call. I’ll discuss API gateways in chapter 8. API gateways in Chapter 8. South America  Phone Number

The third alternative, which is shown in figure 7.6 is to create the API composer that can be used as an independent application. South America  Phone Number database

It is recommended to use this method to query an operation employed internally by multiple services. It is also a possibility for queries that are accessible externally and whose aggregate logic is too complicated to be considered part in an API gateway.

API COMPOSERS MUST CONDUCT A REACTIVE PROGRAMMING MODEL

In the development of an distributed system, minimizing latency is a constant issue. When feasible it is recommended that an API composer should be able to call providers in parallel to reduce the time it takes for queries. For example, the Find Order Aggregator should, for instance, call all four providers concurrently since there is no dependence among the requests. Sometimes, however it is possible that an API composer requires the results of a provider service to call another. In this scenario it would need to invoke some, but not all of the providers in a sequence. South America  Phone Number lists

The process of efficiently executing the simultaneous and sequential service invo-cations is often complex. In order for an API composer to be maintainable as well as performant and scalable, it should use a reactive design based on Java Completable-Future’s, RxJava observables, or some other equivalent abstraction. I will discuss this further in chapter 8, where I go over API gateways. API Gateway pattern.

The advantages and disadvantages from API composition patterns. API composition pattern

This is a straightforward and straightforward way to build queries within a microservice architecture. However, there are some limitations:

More overhead

Risque of less availability

Inconsistency in transactional data

Let’s take a closer look at these.

INCREASED OVERHEAD

A drawback to this method is the time and effort involved in calling several services and querying multiple databases. In a monolithic app the client is able to retrieve information with just one request, which is typically run a single database search. However, using API composition API composition pattern requires numerous database queries and multiple requests. In the end, greater computing resources and networks are needed, thereby increasing costs for running an application. South America  Phone Number lists

Risk of reduced availability

Another disadvantage of this model is the reduced availability. As discussed in chapter 3 accessibility of an operation diminishes according to the number of providers involved. Since the process of creating the query operation requires at least three different services–the API composer, and at least two providers–its availability will be much lower than the availability of just one service. If, for instance, the availability of a single service is 99.5 percent that means that of findOrder’s() endpoint that calls four service providers can be calculated as 99.5%(4+1) is 97.5 percent! South America  Phone Number database

There are several strategies that you can employ to increase the availability of your API. The first is to use an API composer to provide previously stored data when the Provider service is not available. A API composer can cache the information returned by a provider service to boost performance. It also uses this cache to boost accessibility. If a service is not available and the API composer is not available, the API composer will retrieve data from the cache, even though it might be outdated. email marketing database South America  Phone Number

South America  Phone Number leads

Another way to improve accessibility is to allow an API composers to provide complete information. Imagine, for instance, that the Kitchen Service is temporarily unavailable. For example, the API Composer for the findOrder() query could exclude the information of that service from the return, since the UI will still show useful details. There are more details on API structure, caching and the reliability of APIs in chapter 8. buy South America  Phone Number database online

INCONSISTENCY OF TRANSACTIONAL CONSISTENT DATA

Another disadvantage of an API composition patterns is that it lacks consistency of data. Monolithic applications typically perform queries with a single database transaction. ACID transactions–subject to the fine print about isolation levels–ensure that an application has a consistent view of the data, even if it executes multiple data-base queries. However API composition patterns API composition pattern runs multiple database queries against different databases. It is possible that the query operation may produce data that is inconsistent.

For instance, an order obtained through Order Service might be in the CANCELLED status, while the ticket correspondingly retrieved through Kitchen Service might not yet be cancelled. The API composer needs to work out this difference, which can increase the complexity of the code. In addition the API composer may not be able to recognize inconsistent data, and then send it back to the user. South America  Phone Number lists

However, despite these disadvantages, even with these drawbacks, API composition method is highly beneficial. It is a great way to create a number of queries. However, there are some queries that aren’t efficiently executed using this pattern. A query operation could be, for instance, requiring to use the API composer to carry out an in-memory joining of massive databases.

It is generally better to perform these kinds of queries by with this CQRS pattern. Let’s look at how this pattern functions.

Utilizing the CQRS pattern

Many business applications employ the RDBMS as the system of record, and also text search databases like Elasticsearch or Solr to answer text-based search queries. Certain applications keep the databases in sync using writing both at the same time. Others periodically copy files from RDBMS into the search engine for text. Applications using this model leverage the advantages of several databases: the transactional characteristics of the RDBMS as well as the ability to query text databases. South America  Phone Number mailing lists

CQRS is a broadening of this type of architecture. It is a system that has one or more view databases — not only text search databases that are able to implement any of the application’s queries. To comprehend why this is important, let’s take a look at some queries which aren’t able to be efficiently implemented with CQRS’s API the composition patterns. I’ll describe the way CQRS operates and then go over the advantages and disadvantages of CQRS. Let’s examine the scenarios where you’ll need to utilize CQRS.

The reasons to use CQRS

API composition pattern API composition pattern can be used to create a variety of queries that need to retrieve information from several services. However, it’s only one part of the solution to the issue of querying within microservices. This is because there are many service queries that the API composition pattern cannot effectively implement. South America  Phone Number mailing lists

Additionally There are specific service-specific queries, which can be hard to implement. The database of the service may not effectively allow for the query. In other cases, it may make sense for a service to create queries that access information owned by another service. Let’s look at these issues, beginning with a multi-service query which isn’t able to be implemented efficiently using API composition. South America  Phone Number database

INSTALLING THE FINDORDERHISTORY() QUALITY OPERATION

This findOrderHistory() operation will retrieve the history of an order by a consumer. It comes with a variety of parameters:

consumerId–Identifies the consumer

pagination–Page of results that returns

filtering criteria. These include the maximum age for orders that must be returned and an optional status for the order and keywords that are compatible with the restaurant’s namesake and the menu item South America  Phone Number mailing lists

This query operation produces an OrderHistory object which contains an overview of all the orders that match, sorted according to age. The module that creates this Order History view. The view provides an overview of every order, including details about the number of orders, the status of the order along with the total of the order and the estimated delivery date.

At first glance, the procedure is identical to that of the FindOrder() request operation. The only difference is that it will return more than one. It might seem to be that an API composer is required to perform the exact same query for every Provider service and then mix the results. It’s actually not that easy.

This is because not all services have the attributes used to filter or sort. For instance among the findOrderHistory() procedure’s filtering criteria is a keyword that is matched against an item in the menu. Two of the services, Order Service and Kitchen Service keep an Order’s menu items. However, neither Delivery Service nor Accounting Service store the menu items and therefore cannot filter their information using this key word. Similar to that neither Kitchen Service nor Delivery Service can sort data using the orderCreationDate parameter. South America  Phone Number quality lists
There are two ways that an API composer could address this issue. One option can be to ask the API composer to create an in-memory joining, as illustrated in Figure 7.7. It collects all orders of the user via Delivery Service and Accounting Service and joins the orders that are retrieved through Order Service and Kitchen Service. South America  Phone Number database
The disadvantage of this method is that it may require an API composer to search and join massive datasets, which can be inefficient.
Another solution is to use an API composer to fetch matches between requests in the Order Service and Kitchen Service and then ask for orders from other services with the same ID. However, this solution is only feasible in the case of services that have an API for bulk fetch. Individually requesting orders will cause inefficiency due to excessive network traffic. email marketing database South America  Phone Number

South America  Phone Number Profile

For queries like findOrderHistory,() call on the API composer replicate the functions of the queries execution engines. On the other hand, this could mean that work is moved from the less-scalable database to the more flexible application. However it’s inefficient. Developers should also write business-related functionality rather than an engine to execute queries. buy South America  Phone Number database online