The documentation suggests doing this using hooks. Sample code (should be in conftest.py file):

import pytest
import os.path

@ pytest.hookimpl (tryfirst = True, hookwrapper = True)
def pytest_runtest_makereport (item, call):
     # execute all other hooks to obtain the report object
     outcome = yield
     rep = outcome.get_result ()

     # we only look at actual failing test calls, not setup / teardown
     if rep.when == "call" and rep.failed:
         mode = "a" if os.path.exists ("failures") else "w"
         with open ("failures", mode) as f:
             # let's also access a fixture for the fun of it
             if "tmpdir" in item.fixturenames:
                 extra = "(% s)"% item.funcargs ["tmpdir"]
             else:
                 extra = ""

             f.write (rep.nodeid + extra + "\ n")

https://docs.pytest.org/en/latest/example/simple.html#post-process-test-reports-failures

Something like

SELECT activities.id, COUNT(1) GROUP BY activities.id

Since you aren't giving it content in your select worth grouping by you should have no reason to group by anything at all. Your select suggests the same outcome as: SELECT COUNT(activities.id)

obviously that would be your total and not your per activity.

would give you each activity id along with how many times it appears in your dataset. However, it's hard to validate without knowing what your dataset actually contains.

Also I would suggest not using keywords as column names as it's generally frowned upon.

I have a list of people that varies between 2-5k entries that has this general format:

firstname1 lastname1, firstname2 lastname2, firstname3 lastname3 ...

I have a user_table which contains about 250-300k entries with a firstname and lastname column. What I'm trying to do is let users input that list of names into a field, and return all users in the database with matching names. My first instinct was to create a view called name_search that looks like this ->

create view name_search as (
  select
    id,
    to_tsvector(concat(firstname, ' ', lastname)) as search_field
  from user_table
)

Then I can search against it by turning all the names in the comma separated list into a string like this

const queryString = "(firstname1 lastname1) | (firstname2 lastname2) | (firstname3 lastname3) ..."

then I can pass that string into this query

select
  *
from name_search 
where search_field @@ to_tsquery(queryString)

I'm leaving out some of the details like escaping the string etc etc. but my issue is that this is horribly slow. I was wondering if someone could help me create a solution to this that is faster.

I have a Microsoft SQL Server database with dozens of tables and perhaps thousands of columns. Most of the code that ran queries against the database (read and write) is now out of service (like 80%). I'd like to start deleting those obsolete columns and tables.

Is there any product, command or feature that will allow me to track what columns have been read from, or written to, over a specific time frame? Something that sort of mimics a code coverage report in unit testing? I've seen columns_updated, but it only handles the writes, not the reads for me.

You can use the AGE function. For more details check https://www.postgresql.org/docs/current/functions-datetime.html

Something like this, may be?

sum(case transaction_type when 'debit' then -1 else 1 end * amount)
over (partition by vault_id order by id rows unbounded preceding and current row)

Assume 2 node 1 file share cluster (Node 1 is active), where say the file share is down for some reason. The dynamic quorum will allow cluster to continue working and assign the voting capability randomly to one of the nodes. Assume the vote is assigned to node 1.

Now assume node 2 goes down, the cluster will still be online. Say a config change is made to node 1 (note that node 2 is down). Then node 1 is shut down.

Now node 2 is started and say the file share is also online. At this point the file share won't have the correct latest config update time, and neither will the node 2 have the updated config.

This will result on partition in time scenario. How is this handled?

I am troubleshooting query performance issues when running large queries against an AWS Redshift cluster. The majority of the time is spent transferring the data over the network and processing the data in the application. I am not concerned with the amount of time it takes the Redshift cluster to execute the query and start returning data.

I am trying to devise a test where I can measure and quantify the maximum throughput of the Redshift cluster over the AWS network to the EC2 instance I'm testing on. I want to discard the result set as quickly as possible as to not add any additional overhead.

The end result will be to compare the maximum throughput of the cluster and network, to the performance I am seeing in the application processing the data. Ultimately, this will allow me to better understand where my bottlenecks are and what maximum target I can achieve from Redshift.

I already know that the end to end processing speed of the data (33MB/s) seems well below the network and Redshift potential. I want to quantify the upper limit of that throughput.

Is there a mechanism or tool through which to do this? I can use Windows or Linux to do this. I would prefer to use an ODBC connection to closely simulate the application and existing driver. Or any other method for which to measure what I am asking about?

I've considered jMeter, but I'm not sure this is the most direct and simplest approach. I also tried using SQL Server Import and Export Wizard, but it's really stinking slow and clearly not pushing the network or cluster and it also has additional overhead to save the data to disk.

Yes. And probably a lot.

You never gain performance using character(n)(alias char(n)). You don't gain anything at all because that type is outdated, mostly useless, and https://wiki.postgresql.org/wiki/Don%27t_Do_This#Don.27t_use_char.28n.29 . Related:

• https://dba.stackexchange.com/questions/89429/would-index-lookup-be-noticeably-faster-with-char-vs-varchar-when-all-values-are/89433#89433

But you saw that bit in the quote from https://www.postgresql.org/docs/current/datatype-character.html where it says:

apart from increased storage space when using the blank-padded type

char(n) is the blank-padded type. And column names like comment indicate mostly blank-padded waste. text or varchar remove the bloat and everything around your table becomes substantially faster, as your avg. row size probably shrinks to less than half. More tuples per data page means fewer pages to read and process per query, and that is the most important factor for performance there is.

While being at it, order columns favorably to make it more efficient, yet:

   Column      |     Type      | Collation | Nullable | Default 
---------------+---------------+-----------+----------+---------
 orderkey      | integer       |           | not null | 
 custkey       | integer       |           |          | 
 orderdate     | date          |           |          | 
 shippriority  | integer       |           |          | 
 totalprice    | numeric(12,2) |           |          | 
 orderstatus   | varchar(1)    |           |          | 
 orderpriority | varchar(15)   |           |          | 
 clerk         | varchar(15)   |           |          | 
 comment       | varchar(79)   |           |          |

Why?

• https://stackoverflow.com/a/7431468/939860

I kept the length restrictions with varchar(n), but if those are just arbitrary, use text instead. A tiny bit faster, yet. (And less corner-case hassle.) See:

• https://dba.stackexchange.com/questions/20974/should-i-add-an-arbitrary-length-limit-to-varchar-columns/21496#21496

As @a_horse_with_no_name indicated in their comment, the syntax is correct. The query failed for me due to some issues with the client I used.

Sql server configs (logins/roles/server configs) are stored in masterdb

Jobs/schedules are stored in msdb

Where are the following values stored:

1. Data and log file path of system dbs

2. Data and log file path of user dbs. I want to know this because when I restore master db on another server then it doesn't auto create the user dbs in the GUI.