arca | callback analyzer for ActiveRecord | Date Time Utils library

A simple way to count occurrences is with grep -c 'string' file. So in your case you could use a command substitution within a compound command and do:

My solution is that:

The problem with your original code is that the builtin any function is meant to take a sequence of Boolean values and return True if any of them are True, but you passed it a list of exchanges.

Instead, you should check whether each exchange is present in the data, and use any to figure out if this was True for one or more exchanges:

It seems like what you would want is to simply iterate over your 10 indices like this and perform your operation.

It is not entirely clear what you're trying to do. From your code it seems like you're trying to overwrite the value in SECTOR, with the ones indicated by the different sector columns (A guess based on their names).

Basically the problem here is that you are not performing any assignment. For example

I don't think that your query actually works.
Maybe it works coincidentally for the data you have and the specific date '2021-04-01'.
If you want to get for a specific date the highest price of each stock, you should join the tables, group by stock and aggregate:

That's the way Kafka transactions work. Published records are always written to the log, followed by a marker record that indicates whether the transaction committed, or rolled back.

To avoid seeing the rolled-back records, you have to set the consumer isolation.level property to read_committed (it is read_uncommitted by default).

EDIT

It's because you are starting a new transaction:

I make a file with your text. and here's the code. you can repeat it for df_func. enjoy.

At this point it's just a speculation on my part without knowing more about the code and architecture, but it's worth mentioning one thing that jumps out to me. The health check might not be using the normal code path that your other endpoints use, potentially leading to a false positive. If you have the option, use of a profiler could help you pin-point exactly when and how this happens. If not, we can take educated guesses where the problem might be. There could be a number of things at play here, and you may already be familiar with these, but I'm covering them for completeness sake:

First of all, it's worth bearing in mind that connections in Postgres are very expensive (to put it simply, it's because it's a fork on the database process) and your pods are consequently creating them in bulk when you scale your app all at once. A relatively considerable time is needed to set each one up and if you're doing them in bulk, it'll add up (how long is dependent on configuration, available resources..etc).

Assuming you're using ASP.NET Core (because you mentioned DbContext), the initial request(s) will take the penalty of initialising the whole stack (create min required connections in the pool, initialise ASP.NET stack, dependencies...etc). Again, this will all depend on how you structure your code and what your app is actually doing during initialisation. If your health endpoint is connecting to the DB directly (without utilising the connection pool), it would mean skipping the costly pool initialisation resulting in your initial requests to take the burden.

You're not observing the same behaviour when your load increases gradually possibly because usually these things are an interplay between different components and it's generally a non-linear function of available resources, code behaviour...etc. Specifically if it's just one new pod that spun up, it'll require much less number of connections than, say, 5 new pods spinning up, and Postgres would be able to satisfy it much quicker. Postgres is the shared resource here - creating 1 new connection would be significantly faster than creating 100 new connections (5 pods x 20 min connections in a pool) for all pods waiting on a new connection.

There are a few things you can do to speed up this process with config changes, using an external connection pooler like PgBouncer...etc but they won't be effective unless your health endpoint represents the actual state of your pods.

Again it's all based on assumptions but if you're not doing that already, try using the DbContext in your health endpoint to ensure the pool is initialised and ready to take connections. As someone mentioned in the comments, it's worth looking at other types of probes that might be better suited to implementing this pattern.