A Fine Slice Of SQL Server
The Postgres database management system was originally designed as object-relational. We remind why PostgreSQL is an object-relational rather than just relational database management system, and briefly discuss what kind of object-oriented features it offers. We demonstrate how these features can be used to manage hierarchies, and how applications can benefit using them.
Click through for a technique native to PostgreSQL.
Leave a CommentHaripriya Naidu runs an experiment:
Instead of looking at which option is faster, you may want to look at which option is better suited for a given context. Let’s take a look at 2 common options to insert data and analyze them.
INSERT INTO TARGETTABLE SELECT * FROM SOURCETABLE OR SELECT * INTO TARGETTABLE FROM SOURCETABLE
Click through for a comparison of the two, not just for which is faster but also the pros and cons of each approach.
Leave a CommentVlad Drumea is looking for matches:
Figuring out object dependencies in a SQL Server database, especially one you’re not familiar with, can be a challenge.
Luckily, Microsoft provides the sys.sql_expression_dependencies system catalog view to help DBAs and developers track down various object dependencies.I leveraged this catalog view in a query that returns the necessary info in a more user-friendly way, while also allowing easy filtering for referenced or referencing object.
Click through for the script. It’s been a while since I’ve used this DMV in anger, though my recollection is that I had problems finding dependencies over linked servers.
Leave a CommentAndy Brownsword takes a look at one quality of life improvement in SQL Server 2022:
Window functions allow us to perform a function across a set of rows in a result set, rather than how we might typically group them. In SQL Server 2022 we have a new clause available for our queries which can help tidy up how these are defined.
You can do some neat things with the WINDOW clause, including partial matches. For example, you could define a window r1 AS (PARTITION BY x.MyColumn) and then another window r2 AS (r1 ORDER BY x.SomeOtherColumn). I don’t think there are a huge number of scenarios in which this is helpful, especially because performance typically depends upon minimizing the unique number of window functions in your query, but every once in a while it’s a really neat thing.
Rajendra Gupta shows off a nice feature in SQL Server 2022:
Suppose you are a data strategist or analyst for an organization. You have been tasked with getting actionable insights from customers who want to track customer patterns at different intervals, such as hourly, daily, or weekly. To do this, you need to use several date functions such as DATEADD, DATEDIFF, DATEPART, and DATEFROMPARTS to get the required date format.
In SQL Server 2022, this got a lot easier to do using the DATETRUNC function.
Solutions using DATETRUNC() are significantly easier to read and understand than the alternative of combiningDATEADD() and DATEDIFF()
Umair Shahid preps for an update:
When multiple transactions need to modify the same rows, ensuring data consistency can become tricky. A single wrong approach to locking can lead to suboptimal performance or even bring your application to a standstill as numerous transactions block one another. One tool in PostgreSQL’s arsenal to handle concurrency is SELECT FOR UPDATE. It allows you to lock specific rows before updating them, preventing other transactions from modifying those rows until your transaction completes.
In this blog, we will dive deep into SELECT FOR UPDATE in PostgreSQL. We will explore how it helps in reducing contention, avoiding deadlocks, and ultimately boosting performance when dealing with highly concurrent applications.
Click through to understand how this works and also some notes on when to use it and when not to use it.
Leave a CommentChad Callihan deals with non-existent data:
Handling NULL values can be a challenge and may lead to unexpected query results when mixed in with non-NULL values. Thankfully, there are a few SQL Server functions devoted to handling NULL values. Let’s look at two of them. The first, NULLIF, will help you to return a NULL value. The second, ISNULL, will help you with an alternative to a NULL value if you need another value in its place.
For the longest time, I strongly preferred COALESCE() over ISNULL() because of how it can handle multiple scenarios, as well as it being ANSI SQL syntax. But it turns out that, if you do only have two things to compare, ISNULL() is a little bit faster.
There is a SET command in SQL Server that changes how much data is returned from some fields. This short post shows what I learned about the SET TEXTSIZE command.
I’m pretty sure that, if I’ve ever used this command before, it was by accident. It’s kind of a neat concept in how it can limit the result size of larger blocks of text, but I think it’s too limiting to be a good solution save for some very specific circumstances.
Leave a CommentRadim Marek clocks in for the day:
The next possible source of confusion when working with time in PostgreSQL is presence of two distinct data types:
timestamp(ortimestamp without time zone)timestamptz(ortimestamp with time zone) Despite what the names suggest, the key difference isn’t whether they store timezone information, but rather how they handle it during storage and retrieval.
Click through for quite a bit of detail and plenty of examples on how to handle date and time data in PostgreSQL. And I’m still jealous about support for intervals, especially in window functions.
Leave a CommentLukas Eder covers mapping functions:
ARRAYtypes are a part of the ISO/IEC 9075 SQL standard. The standard specifies how to:
- Construct arrays
- Nest data into arrays (e.g. by means of aggregation or subqueries)
- Unnest data from arrays into tables
But it is very unopinionated when it comes to function support. The ISO/IEC 9075-2:2023(E) 6.47
<array value expression>specifies concatenation of arrays, whereas the 6.48<array value function>section lists a not extremely usefulTRIM_ARRAYfunction, exclusively (using which you can remove the lastNelements of an array, something I have yet to encounter a use-case for)
There are a few database platforms that support the ARRAY type, as Lukas lays out.