Understanding 'Single' vs "Double" Quotation Marks in PostgreSQL
Tags: sql, postgres, programming, database
Published: 2024-01-19 08:00:00

**Single Quotes: Representing Textual Values**
----------------------------------------------

In PostgreSQL, single quotation marks are used to indicate textual values, often referred to as string literals. These string literals are essential for expressing information like names, descriptions, or any other form of textual data within SQL statements.

### Using Single Quotes for String Values

When inserting data into a database, the string should be encased in single quotes. For instance, if you're adding a new entry to a **products** table, and you want to specify the product name as "Sparkling Water," you would use single quotes as follows:

```sql
INSERT INTO products (product_name, price) VALUES ('Sparkling Water', 1.99);

```

By enclosing the product name in single quotes, you're indicating that "Sparkling Water" is a string literal, allowing PostgreSQL to interpret and store it correctly. Notice how there are no quotes on the price, because the data is a number, not a string. 

### Escaping Single Quotes

Suppose you need to include an actual single quote within your string. In that case, you can't directly use a single quote, as it would prematurely terminate the string. To handle this situation, you use two consecutive single quotes to represent a single quote character within the string. For example, if you want to insert the string "It's a sunny day," you would do it like this:

```sql
INSERT INTO weather_reports (report) VALUES ('It''s a sunny day');
```

By using two consecutive single quotes (**''**), you're escaping the single quote character and ensuring it's treated as part of the string value.

Double Quotes: Identifying Delimited Identifiers
------------------------------------------------

Unlike single quotes, which deal with string values, double quotes are utilized to mark delimited identifiers. These identifiers are names of database objects such as tables, columns, or even roles. The use of double quotes helps distinguish these identifiers and allows for special characters or case sensitivity.

### Quoting for Delimited Identifiers

Suppose you're creating a table named **Employee Records**. Since this name contains a space, which is not a standard character for identifiers, you would use double quotes to define it as a delimited identifier:

```sql
CREATE TABLE "Employee Records" (
    employee_id serial PRIMARY KEY,
    employee_name text
);

```

By enclosing the table name in double quotes, you're indicating that it's a delimited identifier, allowing PostgreSQL to treat the space as part of the name. 

### Case Sensitivity with Double Quotes

Double quotes introduce case sensitivity to identifiers. For instance, if you create a column named "TotalSales" with double quotes, you must always reference it with the same case and double quotes:

```sql
SELECT "TotalSales" FROM sales_data;
```

Without the double quotes, PostgreSQL would interpret the column name in a case-insensitive manner.

Additional Examples
-------------------

### Creating a New Table

Imagine you're creating a new table to store customer reviews. Let's call it "Product Reviews." To ensure the table name is recognized as a single identifier and that the casing is preserved, you can use double quotes:

```sql
CREATE TABLE "Product Reviews" (
    review_id serial PRIMARY KEY,
    product_id integer,
    review_text text
);

```

In this scenario, the double quotes are utilized to create a delimited identifier for the table name "Product Reviews," allowing the use of spaces and upper casing within the name.

### Querying Data with Delimited Identifiers

Suppose you want to retrieve reviews from the "Product Reviews" table where the product name is "Sparkling Water". Since the table name contains capitalization and spaces, you would need to use double quotes:

```sql
SELECT review_text
FROM "Product Reviews"
WHERE product_name = 'Sparkling Water';

```

Here, the double quotes ensure that PostgreSQL correctly interprets the capitalized table name "Product Reviews.", and the single quotes are used to encase the string used as a search term in the WHERE clause. 

### Using Single Quotes for String Values

Let's insert a new review into the "Product Reviews" table. The review text is "Great product, highly recommended!":

```sql
INSERT INTO "Product Reviews" (product_id, review_text)
VALUES (1001, 'Great product, highly recommended!');

```

In this case, the single quotes are used to enclose the review text, indicating that it's a string value to be inserted into the table.

### Escaping Single Quotes in String Values

Suppose you receive a review with an apostrophe within the text. For example, "It's the best choice." To insert this review accurately, you need to escape the apostrophe using two consecutive single quotes:

```sql
INSERT INTO "Product Reviews" (product_id, review_text)
VALUES (1002, 'It''s the best choice.');

```

By doubling the single quotes (''), you're correctly inserting the review without prematurely ending the string.

Conclusion
----------

Understanding the use of single and double quotation marks in PostgreSQL is critical for effective database manipulation. Single quotes represent textual values, while double quotes denote delimited identifiers, such as table and column names.