First of all, you need to define better what you want to measure. Imagine a sports team. One could say that "improving" means "winning more games" - and one could say that a software team is "improving" when the product is making more money or has a bigger user base. However, in both cases, one can break down what makes the team and analyse specific aspects. It will be highly contextual, depending on your strategy (both in the sport and on the software development).

One common important factor for testers is "are we being able to test more, or are we doing other things?". If that's important to you, you can look at Session-Based Test Management (SBMT).

The data input for SBMT will be the test charters:

From the charters, you can extract information. For instance, how much of the tester's time is spent in different activities:

This can identify problems with testability for instance.

Or how many testing sessions are done throughout time:

Of course, you can think of many other things: You can make a word cloud from the "Bugs" session, in order to identify things that more frequently happening on the bugs; how are you dividing your testing between OS/devices, etc...

DECLARE @content TABLE
(
    title VARCHAR(10) NOT NULL,
    topic VARCHAR(10) NOT NULL,
    id_user INT NOT NULL
);

INSERT INTO @content (title, topic, id_user)
VALUES
(N'Title 1', N'Topic 1', 1),
(N'Title 2', N'Topic 1', 1),
(N'Title 3', N'Topic 2', 2),
(N'Title 4', N'Topic 1', 3),
(N'Title 5', N'Topic 1', 1),
(N'Title 6', N'Topic 1', 3),
(N'Title 7', N'Topic 2', 2);

-- Your solution for reference
SELECT   topic,
         id_user,
         COUNT(*) AS total
FROM     @content
GROUP BY topic,
         id_user
ORDER BY total DESC;

-- Desired solution with undefined behaviour if there are multiple users with the highest total value
WITH cte
AS (SELECT   topic,
             id_user,
             COUNT(*) AS total,
             ROW_NUMBER() OVER (PARTITION BY topic ORDER BY COUNT(*) DESC) AS num
    FROM     @content
    GROUP BY topic,
             id_user)
SELECT cte.topic,
       cte.id_user,
       cte.total
FROM   cte
WHERE  cte.num = 1;

You could use the ROW_NUMBER() windowed function to find the users with the biggest total.

I only want to show the one with the highest total count value of their respective Topic

This implies that there is in some way made sure, that there is always one user with the highest total.

I currently have a SQL Server 2014 instance with a very basic AAG setup. There are 2 nodes in the AG. The Log drive on the primary has 90% free space, and the log drive on the secondary has 5% free space. I guess the 2 questions I have are:

1. Shouldn't they always be more or less the same size since they are synchronized?
2. How can I shrink the log size on the secondary without making it the primary first?

Is there a way to accomplish the second one without doing a manual failover, making it the primary then doing all the work? How can i prevent this massive size discrepancy in the future or is this just to be expected? Thanks in advance for any help.

1: What is the best way to store data of a product in invoice? Is it by bringing the id of the product, or by bringing all info related to the product? Actually is it a good practice to store id of the product in the invoice not all the product data (as I heard before), especially in this situation?

Storing only the ID of the product in the invoice table would be the correct way to relate the two.

2: What is the best way to delete the product in this situation? Is it for example, by creating deleted or delete_status column and assign 0 if the product is not deleted and 1 if it is deleted, and display all products in the invoice page regardless of delete status (and select products that are not deleted in the products page). Or, just by adding product info to the invoice not the product id, so this way no need to join tables together.

Use a DELETED column, and never hard delete the row from the database. This way all existing invoices can still reference a product that was sold. The only time you might want to really delete a row is if the product never really existed and was created by mistake.

3: Same thing for update, if I change product name, it will change also on an already created invoice with the same product. What is the best way to update the product info and prevent this from happeneing?

You should only be changing the product name if it is truly incorrect. Otherwise, you're technically creating new product. If the name was incorrect, such as typo, you would want the update to reflect on all previous invoices. For example, You would not create a product called “Mountain Bike” and then rename it later to “Skateboard”. Those would be different products entirely. In that case, you’d want to create a new product. However, if you created “mountain bake” by mistake, you would want to update it to “mountain bike”, since that just fixing a typo.

As for a FK, you will want to considering creating one from Invoice.ProductID to Product.ID. This serves two purposes.

1. It prevents an invoice from being created with a line item for a product that does not exist
2. It prevents a product from being deleted if it’s referenced on an Invoice.

Lastly, you probably need a third table, InvoiceLineItem.

In that scenario, Invoice would contain order header type info, such as customer, shipping address, etc. InvoiceLineItem would contain reference to each product ordered, qty, and map back to Invoice and Product.

Link: https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-r2-and-2008/cc770830(v=ws.10)#local-two-node-cluster

It says that the disk witness is the recommended best option.

Assuming an FCI solution is planned on a SAN, is disk witness still the recommended best option for 2 node cluster (versus file share) in SQL server 2019?

It's not a unique problem to MAXDOP = 0, rather it's just easier for excessive waiting to happen between parallel threads and increased overhead when there are more threads used for parallelism for a given set of processes in a query. With MAXDOP = 0 there is no limit (up to the number of CPU cores allocated to the server) on how many threads can be used when a subset of operations in a query plan go parallel.

In the Brent Ozar article you linked, https://www.brentozar.com/archive/2013/08/what-is-the-cxpacket-wait-type-and-how-do-you-reduce-it/ , he mentions how Microsoft's recommendation is to not set MAXDOP above 8, as there's usually diminishing returns on parallelism in query plans when more than 8 threads are used. This could result in uneven distributions of the work across the parallelized threads, which would result in some threads waiting with nothing to do while the other threads doing the bulk of the work are still processing. This is one way that CKPACKET waits can occur excessively.

Even when the work is evenly distributed, it may be small enough that too many threads are still no more efficient than a few less threads, e.g. 8 threads might process the work just as quickly as 4, and then there's additional overhead for spinning up those threads and also for the coordinator thread to consume the work back from the 8 threads (the "students turning in their homework" part of Brent Ozar's article) which would've been faster / had less overhead for 4 threads.

So again it's not that MAXDOP = 0 is the problem or any specific value for MAXDOP is the solution, rather it's just ensuring your queries and server are configured appropriately based on the typical workload running on it. And that the chances of excessive overhead from parallelism are increased as more cores are allowed to be used for parallelism in a particular query.

For more information on how CXPACKET waits work, please see https://www.sqlshack.com/troubleshooting-the-cxpacket-wait-type-in-sql-server

It seems you only want rows where bitand(ts.flags, 4503599627370512) = 16. No decode/case needed.

select * from ts$ ts
where  ts.contents$ = 0
and    bitand(ts.flags, 4503599627370512) = 16;

Since your Question is tagged with SQL2019 my answer is tested in the same version.

https://docs.microsoft.com/en-us/sql/relational-databases/system-catalog-views/sys-master-files-transact-sql?view=sql-server-ver15

Contains a row per file of a database as stored in the master database. This is a single, system-wide view.

For tempdb, view sys.master_files shows initial tempdb size. The values are used as a template for tempdb creation at startup of SQL Server. So, when tempdb grows it is not reflected in the view. To get current size of tempdb files, query tempdb.sys.database_files.

https://docs.microsoft.com/en-us/sql/relational-databases/system-catalog-views/sys-database-files-transact-sql?view=sql-server-ver15

Contains a row per file of a database as stored in the database itself. This is a per-database view.

https://docs.microsoft.com/en-us/sql/relational-databases/system-dynamic-management-views/sys-dm-server-registry-transact-sql?redirectedfrom=MSDN&view=sql-server-ver15

You can get master database data and log file location from here. You can get the same information by opening 'SQL Server Configuration Manager' located at 'C:\Windows\SysWOW64\SQLServerManager15.msc'.

You will find the same information in old system tables and are discouraged by Microsoft to not use those. https://docs.microsoft.com/en-us/sql/relational-databases/system-tables/mapping-system-tables-to-system-views-transact-sql?view=sql-server-ver15 between old system tables and newer system views

When SQL max memory is not set, then sql can use any amount of memory.

1. Suppose SQL takes all the memory and then OS needs around 4GB memory, then will OS forcibly take the memory from the sql server or will OS use disk paging file?

2. While OS is holding on to the above 4GB memory (for some ongoing OS work), and suppose SQL needs more memory then will SQL forcibly take the memory from OS or will it use the disk paging file?

This is not actually a DBA question but rather a Boolean algebra question (which means it might be more at home on Stack Overflow.)

In short, you want the trigger to fire if EITHER:

• a_number is unchanged and name is changed (or not unchanged) OR
• a_number is unchanged and docketed is not unchanged.

We can then apply distribution ((x AND y) OR (x AND z) == x AND (y OR z)) to reduce the expression, as follows:

Your requirement, as I've restated it above, can be expressed as

(a_number = NEW.a_number AND name != NEW.name) OR (a_number = NEW.number AND docketed != NEW.docketed)

If we let

• x = (a_number = NEW.a_number)
• y = (name != NEW.name)
• z = (docketed != NEW.docketed)

we can rewrite it as

(x AND y) OR (x AND z)

which distributes to

x AND (y OR z)

and substituting our values of x, y and z we get

(a_number = NEW.a_number) AND ((name != NEW.name) OR (docketed != NEW.docketed))

The operators = and != are equivalent to IS and IS NOT except that the latter should be used when one of the operands may be NULL.

I hope this helps.

Edit to add: Part of the OP's confusion was over the NEW element. NEW is a pseudorecord available to ON INSERT and ON UPDATE triggers which represents the record which fired the trigger, as it will appear in the table once the firing transaction is committed.

Figured it out. There is a row in the table for each partion. I was the filtering on table name not the partition name.