T-SQL — Notes.ipynb

{
    "metadata": {
        "kernelspec": {
            "name": "SQL",
            "display_name": "SQL",
            "language": "sql"
        },
        "language_info": {
            "name": "sql",
            "version": ""
        }
    },
    "nbformat_minor": 2,
    "nbformat": 4,
    "cells": [
        {
            "cell_type": "markdown",
            "source": [
                "# **T-SQL Fundamentals**"
            ],
            "metadata": {
                "azdata_cell_guid": "144b4c0c-fb0b-4f2c-8985-e6a917fcd95a"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "# **Le Proposizioni**"
            ],
            "metadata": {
                "azdata_cell_guid": "414bae17-8b14-4642-ae6b-3f87bef001c7"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Il Flusso Logico di una QUERY\r\n",
                "\r\n",
                "1. **FROM**\r\n",
                "2. **WHERE**\r\n",
                "3. **GROUP BY**\r\n",
                "4. **HAVING**\r\n",
                "5. **SELECT**\r\n",
                "    - Expressions, Ex. **WINDOW FUNCTIONS**\r\n",
                "    - **DISTINCT**\r\n",
                "6. **ORDER BY**\r\n",
                "    - **TOP/OFFSET-FETCH**"
            ],
            "metadata": {
                "azdata_cell_guid": "ece598c3-5c73-4b21-bfcc-6b499e3c824e"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "## La proposizione **HAVING.**\r\n",
                "\r\n",
                "Dove la proposizione **WHERE** agisce da filtro per le righe, **HAVING** è il filtro che agisce sui gruppi, accompagnando la proposizione **GROUP BY.**"
            ],
            "metadata": {
                "azdata_cell_guid": "706f92fa-5d49-4a47-8298-86bdcd438acd"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT \r\n",
                "    empid,\r\n",
                "    YEAR(orderdate) AS orderyear,\r\n",
                "    COUNT(*) AS numorders\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "WHERE custid = 71\r\n",
                "GROUP BY empid, YEAR(orderdate)\r\n",
                "HAVING COUNT(*) > 1;"
            ],
            "metadata": {
                "azdata_cell_guid": "dbcd0983-e511-4578-9943-a4026c244b3a",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Le proposizioni **SELECT** e **DISTINCT.**\r\n",
                "\r\n",
                "Con la preposizione **SELECT** si elencano i campi (o \"colonne\") che la query dovrà fornire come risultato, *con o senza manipolazioni*. Inoltre:\r\n",
                "\r\n",
                "- Opzionalmente è possibile specificare la proposizione **AS** per specificare un alias per il campo desiderato. As esempio: ***SELECT Orderdate AS \"Data Ordini\"***\r\n",
                "\r\n",
                "- Con la proposizione **DISTINCT** E' possibile ottenere il risultato di una query privo di elementi duplicati.\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "f94ba757-a63e-4177-a328-c8b7f41e9bfc"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT DISTINCT \n",
                "    empid,\n",
                "    YEAR(orderdate) AS \"Anno Ordine\"\n",
                "FROM TSQLV4.Sales.Orders\n",
                "WHERE custid = 71;"
            ],
            "metadata": {
                "azdata_cell_guid": "cc04e7f0-b489-4fa1-b0b5-16238d9c0e0c",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## La proposizione **ORDER BY.**\r\n",
                "\r\n",
                "La proposizione **ORDER BY** consente di specificare una logica di ordinamento per i risultati prodotti dalla proposizione **SELECT.** In **ORDER BY** è possibile specificare campi non presenti in **SELECT**, come, ad esempio:"
            ],
            "metadata": {
                "azdata_cell_guid": "7ffa3eaa-4f0a-4ab3-b66c-4bbfcf1aeac0"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT \r\n",
                "    empid,\r\n",
                "    firstname,\r\n",
                "    lastname,\r\n",
                "    country\r\n",
                "FROM TSQLV4.HR.Employees\r\n",
                "ORDER BY hiredate;"
            ],
            "metadata": {
                "azdata_cell_guid": "f0d389a2-6368-487c-9bec-22fa68e79333",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **TOP** e **OFFSET-FETCH.**\r\n",
                "\r\n",
                "\r\n",
                "### **TOP**\r\n",
                "\r\n",
                "Il filtro **TOP** è un costrutto proprietario di T-SQL che è possibile usare per limitare il numero o la percentuale di righe come risultato di una query:"
            ],
            "metadata": {
                "azdata_cell_guid": "53dfe159-d8de-4e4a-8bc7-fa4b48e5313f"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT TOP (5) \r\n",
                "    orderid,\r\n",
                "    orderdate,\r\n",
                "    custid,\r\n",
                "    empid\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "ORDER BY orderdate DESC;"
            ],
            "metadata": {
                "azdata_cell_guid": "85d016e6-7d0d-4de6-ad77-38d3cbc4bfb7"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT TOP (1) PERCENT \r\n",
                "    orderid, \r\n",
                "    orderdate,\r\n",
                "    custid,\r\n",
                "    empid\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "ORDER BY orderdate DESC;"
            ],
            "metadata": {
                "azdata_cell_guid": "53be7b9c-47e5-4d76-8b25-7fcef355af42",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "L'output di una query con il costrutto **TOP** è non-deterministico, cioè, qualora vi siano duplicati o righe di pari valore, non vi è alcuna regola che determini quale partiolare delle *n* righe che rispondono ai requisiti stabiliti verrà scelta. **Vi sono due rimedi:**\r\n",
                "\r\n",
                "- Aggiungere una regola **ORDER BY** *DESC*, in modo tale che la riga con il valore più grande venga preferita alle altre;\r\n",
                "\r\n",
                "- Aggiungere il costrutto **WITH TIES** in modo tale che la query consegni come risultato anche le righe di pari valore;"
            ],
            "metadata": {
                "azdata_cell_guid": "074ab925-99cc-40f8-8ef9-3049c3f34e6f"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT TOP (5) WITH TIES \r\n",
                "    orderid, \r\n",
                "    orderdate, \r\n",
                "    custid, \r\n",
                "    empid\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "ORDER BY orderdate DESC;"
            ],
            "metadata": {
                "azdata_cell_guid": "12840f59-138d-4a52-8d20-4e2cb8984d39"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "### **OFFSET-FETCH**\r\n",
                "\r\n",
                "Considerato un'estensione di **ORDER BY**, **OFFSET-FETCH** consente di saltare righe (OFFSET) e filtrarne altre (FETCH). Il codice seguente salterà le prime 50 righe e mostrerà le seguenti 10:\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "0ea41d4d-c457-475d-b306-e94a7dc88b82"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT orderid, orderdate, custid, empid\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "ORDER BY orderdate, orderid\r\n",
                "OFFSET 50 ROWS FETCH NEXT 10 ROWS ONLY;"
            ],
            "metadata": {
                "azdata_cell_guid": "6c274d1b-7f95-4c2f-90bf-938031876adc"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "Tramite **OFFSET** 0 **ROWS** è possibile evitare di saltare righe, indicando in **FETCH FIRST** *N* **ROWS ONLY** il numero di righe da mostrare. In tal modo il codice si comporterà come **SELECT TOP (N)**."
            ],
            "metadata": {
                "azdata_cell_guid": "aaf468b9-12ce-4838-8665-b4467ca15b47"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT orderid, orderdate, custid, empid\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "ORDER BY orderdate, orderid\r\n",
                "OFFSET 0 ROWS FETCH FIRST 10 ROWS ONLY;"
            ],
            "metadata": {
                "azdata_cell_guid": "76ee187f-ef36-45c1-9e72-9d9f120f6eb6"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **CASE-WHEN-THEN** Expressions.\r\n",
                "\r\n",
                "Un **CASE** è un'espressione scalare, cioè restituisce un unico risultato, la quale produce un valore in base ad un'espressione logica condizionale. Esempi:"
            ],
            "metadata": {
                "azdata_cell_guid": "cbdce922-a2be-4091-8eff-f879caa4da0e"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT productid, productname, categoryid,\r\n",
                "    CASE categoryid\r\n",
                "        WHEN 1 THEN 'Beverages'\r\n",
                "        WHEN 2 THEN 'Condiments'\r\n",
                "        WHEN 3 THEN 'Confections'\r\n",
                "        WHEN 4 THEN 'Dairy'\r\n",
                "        WHEN 5 THEN 'Grains'\r\n",
                "        WHEN 6 THEN 'Meat'\r\n",
                "        WHEN 7 THEN 'Produce'\r\n",
                "        WHEN 8 THEN 'Seafood'\r\n",
                "        ELSE 'Unknown'\r\n",
                "    END AS categoryname\r\n",
                "FROM TSQLV4.Production.Products"
            ],
            "metadata": {
                "azdata_cell_guid": "9c02167c-8439-4080-9b64-9da7e4dc0a51"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT orderid, custid, val,\r\n",
                "    CASE \r\n",
                "        WHEN val < 1000 THEN 'Less than 1000'\r\n",
                "        WHEN val BETWEEN 1000.00 AND 3000.00 THEN 'Between 1000 and 3000'\r\n",
                "        WHEN val > 3000 THEN 'More than 3000'\r\n",
                "        ELSE 'Unknown'\r\n",
                "    END AS valuecategory\r\n",
                "FROM TSQLV4.Sales.OrderValues"
            ],
            "metadata": {
                "azdata_cell_guid": "4b2ba678-cc4d-40c0-85a9-a787226ad9e0"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **NULLs.**\r\n",
                "\r\n",
                "T-SQL adotta una logica a tre valori. Da tale condizione risultano:\r\n",
                "\r\n",
                "- Un'espressione logica fra valori non nulli può risultare solo in **TRUE** o **FALSE**. \r\n",
                "\r\n",
                "- Quando un'espressione logica coinvolge un **NULL**, allora darà come risultato **UNKNOWN**. **UNKNOWN** negato risulta sempre in **UNKNOWN.**\r\n",
                "\r\n",
                "- Curiosamente quando un'espressione coinvolge due **NULL** risulterà in **UNKNOWN.**\r\n",
                "\r\n",
                "- **GROUP BY** e **ORDER BY** considerano **NULL** differenti come lo stesso valore: verranno dunque raggruppati o ordinati come una singola classe.\r\n",
                "\r\n",
                "Per tutte le query di ricerca è dunque essenziale prevedere una casistica per i risultati **NULL.**"
            ],
            "metadata": {
                "azdata_cell_guid": "f5129d4a-b9c2-4fbc-82cb-cc3eb4a07443"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "# **Esplorare i metadati di un database**"
            ],
            "metadata": {
                "azdata_cell_guid": "4773c968-7f3f-47cd-a8a3-b38f99083da9"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "## @SQL SERVER — **.SYS** Catalog Views\r\n",
                "\r\n",
                "Le **Catalog Views** sono funzioni di SQL Server che permettono di ottenere informazioni dettagliate circa gli oggetti contenuti in un database, come ad esempio le liste di schemas e tabelle."
            ],
            "metadata": {
                "azdata_cell_guid": "d785983b-fdb1-4abf-8a87-ef8b9aa1809c"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "### > Esplorare Schemas e Tabelle di un Database con **sys.tables**"
            ],
            "metadata": {
                "azdata_cell_guid": "b29ca485-103c-430f-b084-a0439e890ac2"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "USE TSQLV4;\r\n",
                "SELECT SCHEMA_NAME(schema_id) AS table_schema_name, name AS table_name\r\n",
                "FROM sys.tables;"
            ],
            "metadata": {
                "azdata_cell_guid": "1c772158-ac5e-4441-abc9-36a95f1f3685",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "### > Esplorare le colonne di una tabella con **sys.columns**"
            ],
            "metadata": {
                "azdata_cell_guid": "655bfed2-d8f6-41c5-9db7-62ad4c0aa559"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--Elenca tutte le colonne della tabella Sales.Orders e le loro proprietà.\r\n",
                "SELECT\r\n",
                "    name AS 'Colonna',\r\n",
                "    TYPE_NAME(system_type_id) AS 'Tipo Dati',\r\n",
                "    max_length AS 'Lunghezza Massima',\r\n",
                "    collation_name AS 'Collation',\r\n",
                "    is_nullable AS 'Accetta NULL?'\r\n",
                "FROM sys.columns\r\n",
                "WHERE object_id = OBJECT_ID('Sales.Orders');\r\n",
                "\r\n",
                "-----------------------------------------------------------------------------------------------------------------------------------------------\r\n",
                "\r\n",
                "--La stessa query con SELECT * ritorna una quantità molto esaustiva di informazioni.\r\n",
                "\r\n",
                "SELECT * \r\n",
                "FROM sys.columns\r\n",
                "WHERE object_id = OBJECT_ID('Sales.Orders');"
            ],
            "metadata": {
                "azdata_cell_guid": "26421ef1-cc35-4bbe-93f6-3cc89a388d0e",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## @SQL STANDARD — **INFORMATION_SCHEMA** Views\r\n",
                "\r\n",
                "Funzionalità standard di SQL — la quale, dunque, non prevede metadati od oggetti specifici a SQL Server — che risiede nello schema **INFORMATION_SCHEMA**."
            ],
            "metadata": {
                "azdata_cell_guid": "865527dd-5cd1-4f6b-8b8c-8863cdc9148e"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--QUERY STANDARD per elencare Schema e Tabelle presenti nel database.\r\n",
                "USE TSQLV4;\r\n",
                "SELECT TABLE_SCHEMA, TABLE_NAME\r\n",
                "FROM INFORMATION_SCHEMA.TABLES\r\n",
                "WHERE TABLE_TYPE = N'BASE TABLE';\r\n",
                "\r\n",
                "----------------------------------------------------------------------------------------------------------------------\r\n",
                "\r\n",
                "--El\r\n",
                "SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, COLLATION_NAME, IS_NULLABLE\r\n",
                "FROM INFORMATION_SCHEMA.COLUMNS\r\n",
                "WHERE (TABLE_SCHEMA = N'Sales') AND (TABLE_NAME = N'Orders')"
            ],
            "metadata": {
                "azdata_cell_guid": "e579bb33-97ca-47dd-8631-898dba3cd334",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **Stored Procedures** di Sistema\r\n",
                "\r\n",
                "Le **stored procedures** (capitolo dedicato più avanti) sono delle query SQL pre-compilate che vengono memorizzate nel database per il loro riutilizzo, una cui efficace implementazione riduce considerevolmente il carico di lavoro per i fruitori della database, siano essi gli amministratori o gli utenti finali, rendendo dispobile una libreria di codice efficiente e riutilizzabile. SQL Server dispone di una serie di **stored procedures per l'estrazione di metadati dal sistema:**\r\n",
                "\r\n",
                "- **sys.sp_tables** — produce una lista di tabelle e view che possono essere ricercati nel database;"
            ],
            "metadata": {
                "azdata_cell_guid": "fe11aaf9-b673-4869-a1b2-7ed592d317a1"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "USE TSQLV4;\r\n",
                "EXEC sys.sp_tables;"
            ],
            "metadata": {
                "azdata_cell_guid": "00a4047e-93c5-486e-8c7d-747d043a165f"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "- **sys.sp_help** — fornisce informazioni generiche su un oggetto, come: colonne, tipi di dati, collation, indici, constraints e altro;"
            ],
            "metadata": {
                "azdata_cell_guid": "04519959-09e4-4d09-8518-5589ef5d51e1"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "USE TSQLV4;\r\n",
                "EXEC sys.sp_help @objname = N'Sales.Orders'"
            ],
            "metadata": {
                "azdata_cell_guid": "6c8cfe3d-453b-4943-9d0c-f74f36014f39"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "- **sys.sp_columns** — fornisce informazioni sulle colonne di un oggetto;"
            ],
            "metadata": {
                "azdata_cell_guid": "0f8a102f-e2f1-45a3-9e27-92e0bc781e76"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "USE TSQLV4;\r\n",
                "EXEC sys.sp_columns @table_name = N'Orders', @table_owner = N'Sales';"
            ],
            "metadata": {
                "azdata_cell_guid": "adaca44b-36db-4e3e-b91c-28ca1d595822"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "- **sys.sp_helpconstraint** — fornisce informazioni sui **constraint** presenti in un oggetto;"
            ],
            "metadata": {
                "azdata_cell_guid": "49a4f8f2-a8a5-4a86-a421-960404b93b21"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "USE TSQLV4;\r\n",
                "EXEC sys.sp_helpconstraint @objname = N'Sales.Orders';"
            ],
            "metadata": {
                "azdata_cell_guid": "ff5232a7-f0df-45b7-8993-45c265d8daf9"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Funzioni per l'Estrazione di Metadati\r\n",
                "\r\n",
                "Oltre a Views e Stored Procedures, vi sono anche funzioni utili per l'estrazione di metadati:\r\n",
                "\r\n",
                "- **DATABASEPROPERTYEX(database_name, property)** — restituisce la proprietà *property* del *database_name* specificato"
            ],
            "metadata": {
                "azdata_cell_guid": "6a178f6c-061b-4daa-ae5e-b10f03d5d09e"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT DATABASEPROPERTYEX(N'TSQLV4', 'Collation');"
            ],
            "metadata": {
                "azdata_cell_guid": "01fccebc-441f-47ab-b0a0-a40e9cc977e7"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "- **OBJECTPROPERTY(object_id, property)** — restituisce la proprietà *property* dell'oggetto definito dall'*object_id* indicato"
            ],
            "metadata": {
                "azdata_cell_guid": "c78c048f-088a-429f-9ff9-8ab8e26c1ca5"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT OBJECTPROPERTY(OBJECT_ID(N'Sales.Orders'), 'TableHasPrimaryKey');"
            ],
            "metadata": {
                "azdata_cell_guid": "eae120cd-a2fe-4fbe-8ff2-33aa7547a618"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "# **Lavorare con Stringhe e Caratteri**\r\n",
                "\r\n",
                "### **Tipi di Caratteri**\r\n",
                "\r\n",
                "SQL Server support due tipi di caratteri: \r\n",
                "\r\n",
                "- **Regolari** — tipi **CHAR(n)** e **VARCHAR(n-MAX)**, consigliati per supportare una sola lingua oltre all'inglese.\r\n",
                "\r\n",
                "    - *'Questa è una stringa di caratteri regolari'*\r\n",
                "- **Unicode** — tipi **NCHAR(n)** e **NVARCHAR(n-MAX)**, consigliati per supportare molteplici lingue.\r\n",
                "\r\n",
                "    - *N'Questa è una stringa Unicode'*\r\n",
                "\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "ec141f47-c092-4f04-9db8-764b35ca5444"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "### **_CHAR e _VARCHAR**\r\n",
                "\r\n",
                "A seguire alcune peculiarità tecniche dei principali campi stringa disponibili:\r\n",
                "\r\n",
                "- **CHAR** e **NCHAR** rappresentano stringhe di un numero fisso, prestabilito di caratteri. Ad esempio, **CHAR(5)** identifica una stringa di massimo 5 caratteri, come ***'ciao'***. Un'ipotetico input ***'Cicciomerda'*** in un campo identificato da un tipo **CHAR(5)** verrebbe automaticamente troncato a ***'Ciccio'***, cioè la sua rappresentazione a 5 caratteri. Per ragioni tecniche, **la dimensione fissa di CHAR rende più veloci le operazioni su questi campi vs. VARCHAR**.\r\n",
                "\r\n",
                "- **VARCHAR** e **NVARCHAR** invece rappresentano campi di stringhe di lunghezza variabile. Per tale ragione è consigliabile inizializzare tali campi come **_VARCHAR(MAX)**. Per ragioni tecniche, la lettura sui campi **_VARCHAR** è più performante rispetto ai campi **_CHAR**.\r\n",
                "\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "5c8b2343-06bc-4539-8f1c-00c98c4d019e"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "### **Collation**\r\n",
                "\r\n",
                "La **Collation** è una proprietà dei dati di tipo stringa che racchiude diverse caratteristiche, come:\r\n",
                "\r\n",
                "- Supporto Linguistico \r\n",
                "- Ordine di ordinamento\r\n",
                "- Case sensitivity\r\n",
                "\r\n",
                "In una comune installazione *on-premise* di SQL, la **Collation** può essere definita a quattro diversi livelli:\r\n",
                "\r\n",
                "- **Istanza** — La collation di un'istanza è definita al momento dell'installazione e viene in tale sede stabilita come il valore di **DEFAULT** per tutti i database utente e di sistema.\r\n",
                "- **Database** — Specificata mediante la chiave **COLLATE**, oppure stabilita con il valore di default. Stabilisce la collation per le tabelle ed i metadati (e.g. *Oggetti* e *Campi*)dello specifico database.\r\n",
                "- **Colonna** —  Stabilita mediante **COLLATE** oppure assunta come il default del database.\r\n",
                "- **Espressione** — Stabilita mediante **COLLATE** oppure assunta come il valore di default.\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "95b1f85e-4720-4e85-8a6d-915e02cc3072"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **Operatore \"+\" e CONCAT(string1, string2, ..., string*n*)**\r\n",
                "\r\n",
                "L'operatore **+** consente la concatenazione di strighe. Secondo SQL standard, la concatenazione di una qualsiasi stringa con NULL da esito NULL. Tale evenienza è rimediata dalla funzione **CONCAT( )**, la quale sostituisce ai valori NULL delle stringhe vuote ' '."
            ],
            "metadata": {
                "azdata_cell_guid": "2258ffc5-12d1-4ec7-b52f-a2264952a612"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SET NOCOUNT ON --Riduce i messaggi a completamento delle query.\r\n",
                "\r\n",
                "SELECT empid, \r\n",
                "       firstname + N' ' + lastname AS 'Full Name'\r\n",
                "FROM TSQLV4.HR.Employees;\r\n",
                "\r\n",
                "SELECT TOP (10) custid, country, region, city, country + N', ' + region +N', ' + city AS 'Location'\r\n",
                "FROM TSQLV4.Sales.Customers\r\n",
                "\r\n",
                "SELECT TOP (10) custid, country, region, city, CONCAT(country, N', ' + region, N', ' + city) AS 'Location'\r\n",
                "FROM TSQLV4.Sales.Customers;\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "43bc3583-89fe-4da3-adee-3450066ad063"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **LEN(string) — DATALENGTH(string)**\n",
                "\n",
                "Producono la lunghezza in caratteri o la lunghezza in bytes di una stringa. <strong>LEN(string)</strong> ignora gli spazi in coda, mentre <strong>DATALENGTH(string)</strong> li considera."
            ],
            "metadata": {
                "azdata_cell_guid": "fb80ec76-1f99-4540-bb8a-4f209de17b55"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT LEN('Cacca') AS 'Character Length',\r\n",
                "       DATALENGTH('Cacca') AS 'Ascii Datalength', \r\n",
                "       DATALENGTH(N'Cacca') AS 'Unicode Datalength';"
            ],
            "metadata": {
                "azdata_cell_guid": "2bbdd6a5-1123-4c13-bac7-fbfc91f2255a",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **SUBSTRING(string, start, length) — LEFT(string, n) — RIGHT(string, n)**\r\n",
                "\r\n",
                "Opera sulla stringa *string* per selezionare la sottostringa di lunghezza *length* a partire dalla posizione *start*. Se la lunghezza *length* supera la sottostringa disponibile dopo *start*, **SUBSTRING()** restituirà la sottostringa fino all'ultimo carattere. Sostituendo *length* con **LEN(string)** possiamo ottenere dinamicamente l'intera sottostringa a partire dal carattere in posizione *start*."
            ],
            "metadata": {
                "azdata_cell_guid": "8bb06b59-b089-4c42-ae6f-36f0a1871cac"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT SUBSTRING('cacca', 2, 4) AS \"SUBSTRING()\",\r\n",
                "       SUBSTRING('cacca', 2, LEN('cacca')) AS \"SUBSTRING() + LEN()\",\r\n",
                "       LEFT('Cacca', 3) AS \"LEFT('Cacca', 3')\",\r\n",
                "       RIGHT('Cacca', 3) AS \"RIGHT('Cacca', 3')\";"
            ],
            "metadata": {
                "azdata_cell_guid": "c09fbc09-e4ae-4a0d-98e9-1839de9bdd3b",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **CHARINDEX(substring, string, [start]) — PATINDEX(pattern, string)**\r\n",
                "\r\n",
                "La funzione **CHARINDEX** restituisce la posizione di *substring* all'interno dell'argomento *string*, dando la possibilità di specificare dove far partire la ricerca con l'argomento *start*. La funzione **PATINDEX** invece restituisce la posizione di un *pattern* all'interno di una *string*."
            ],
            "metadata": {
                "azdata_cell_guid": "d994a28f-c1c4-4cfb-a426-6bcf968eb230"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT CHARINDEX('pupù', 'Caccapupù') AS \"CHARINDEX('pupù', 'Caccapupù')\",\r\n",
                "       PATINDEX('%[0-9]%', 'Ginopastino.90') AS \"PATINDEX('%[0-9]%', 'Ginopastino.90')\";"
            ],
            "metadata": {
                "azdata_cell_guid": "65fc79f2-0562-4cf0-98fc-40eed567f738"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **REPLACE(string, substring1, substring2) — REPLICATE(string, n)**\r\n",
                "\r\n",
                "La funzione **REPLACE** ha il compito di sostituire tutte le occorrenze di *substring1* con *substring2* all'interno dell'argomento *string*. La funzione **REPLICATE**, invece, replicherà l'argomento *string* per *n* volte."
            ],
            "metadata": {
                "azdata_cell_guid": "96f79de6-cf55-40c1-8a1e-c4fff5bd1e50"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT REPLACE(REPLICATE('a', 20), 'a', 'b');"
            ],
            "metadata": {
                "azdata_cell_guid": "95feed20-0613-4c6a-bbc1-580b20d3b396"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "### > Contare il numero di occorrenze di un carattere in una stringa con **REPLACE**:"
            ],
            "metadata": {
                "azdata_cell_guid": "acca8ccc-8576-47b6-8054-4c604fc9c8c2"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--Uso REPLACE() per sostituire il carattere cercato con una stringa vuota.\r\n",
                "--Misuro la differenza fa la stringa risultante e quella originale.\r\n",
                "SELECT empid, lastname, LEN(lastname) - LEN(REPLACE(lastname, 'e','')) AS 'Occurrences'\r\n",
                "FROM TSQLV4.Hr.Employees"
            ],
            "metadata": {
                "azdata_cell_guid": "997e4349-980b-49ab-be7f-84b5247e138d"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **STUFF(string, position, length, insert)**\r\n",
                "\r\n",
                "La funzione **STUFF** opera in *string* sostituendo rimuovendo *length* caratteri alla posizione *position* e vi inserisce una stringa *insert*:"
            ],
            "metadata": {
                "azdata_cell_guid": "67bfc1e0-d742-4d28-bb07-dffaed8065ac"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--Imito il meccanismo di REPLACE con la funzione STUFF\r\n",
                "SELECT STUFF('Caccamerda', CHARINDEX('merda', 'Caccamerda'), LEN('merda'), 'pupù') AS 'STUFF()',\r\n",
                "       REPLACE('Caccamerda', 'merda', 'pupù') AS 'REPLACE()';"
            ],
            "metadata": {
                "azdata_cell_guid": "d7f01bf0-2f0f-4c08-8380-898af21bab4d"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **UPPER/LOWER(string) e RTRIM/LTRIM(string)**\r\n",
                "\r\n",
                "Consentono la trasformazione di *string* da ad Uppercase o Lowercase. Mentre le funzioni **RTRIM/LTRIM** consentono l'eliminazione di spazi in testa o in coda a *string*"
            ],
            "metadata": {
                "azdata_cell_guid": "44d07c14-3fa5-4f5f-9726-c8491f0e6708"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT '  Cacca  ' AS 'Regular', \r\n",
                "       UPPER('  Cacca  ') AS 'Uppercase', \r\n",
                "       LOWER('  Cacca  ') AS 'Lowercase',\r\n",
                "       RTRIM(LTRIM('  Cacca  ')) AS 'No Leading/Trailing Spaces'"
            ],
            "metadata": {
                "azdata_cell_guid": "d3f7e5f0-09d7-4aad-8a12-2cb55228b5f6"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **COMPRESS/DECOMPRESS(string/VARBINARY)**\r\n",
                "\r\n",
                "Le funzioni **COMPRESS/DECOMPRESS** utilizzano l'algoritmo GZIP per comprimere o decomprimere l'argomento.\r\n",
                "\r\n",
                "- **COMPRESS** — Accetta una stringa di caratteri o codice binario come input e restituisce un valore **VARBINARY(MAX)**\r\n",
                "\r\n",
                "- **DECOMPRESS** — Accetta un **VARBINARY(MAX)** in ingresso e lo consegna decompresso. Se il valore originario era di tipo NCHAR/NVARCHAR(MAX), allora sarà necessario incpsulare DECOMPRESS in un blocco **CAST()**, come segue:\r\n",
                "        CAST(DECOMPRESS(value)) AS NVARCHAR(MAX)\r\n",
                "\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "012bec79-36de-4289-828b-734e7e9892a4"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **SELECT *value* FROM STRING_SPLIT(string, separator)**\r\n",
                "\r\n",
                "Al contrario delle funzioni scalari elencate finora, **STRING_SPLIT** è una **funzione tabulare** e cioè una funzione che produce una tabella, anzichè consegnare un singolo valore. Per questa ragione, la sintassi di **STRING_SPLIT** è differente. La funzione ha il compito di suddividere una stringa in elementi individuali, identificati da un carattere separatore — *e.g.* \",\" - \"|\" - \"\\\\\" etc...."
            ],
            "metadata": {
                "azdata_cell_guid": "0ae58b3e-a6a3-487c-bd39-efd46c484ed3"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT CAST(value AS INT) AS 'Valore'\r\n",
                "FROM STRING_SPLIT('1111,2222,3333,4444,5555', ',');"
            ],
            "metadata": {
                "azdata_cell_guid": "e9a63100-5086-4013-9c55-cf154c3d21bd",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **Il predicato LIKE**\r\n",
                "\r\n",
                "Il predicato **LIKE** si può utilizzare per verificare se una stringa contiene un determinato pattern/combinazione. **LIKE** si può configurare mediante l'uso delle seguenti **wildcard**:\r\n",
                "\r\n",
                "- **%** — Rappresenta una stringa di qualsiasi dimensione, inclusa la stringa vuota.\r\n",
                "\r\n",
                "- **_** — Rappresenta un unico carattere.\r\n",
                "\r\n",
                "- **[lista di caratteri]** — Indica un singolo carattere che deve appartenere alla lista specificata. Ad esempio **[ABC]** \r\n",
                "\r\n",
                "- **[carattere-carattere]** — Indica un range di caratteri. Ad esempio **[A-E]** indica qualsiasi carattere dalla A alla E, inclusa. \r\n",
                "\r\n",
                "- **[^lista o range di caratteri]** — La negazione della condizione precedente. Indica un range di caratteri che la stringa **NON** deve contenere. \r\n",
                "\r\n",
                "- **ESCAPE** — E' utilizzato per verificare una stringa per la presenze di un carattere a sua volta utilizzato nel codice come wildcard. Tuttavia per le wildcard %, _, [, è possibile utilizzare la notazione %[ _ ]%."
            ],
            "metadata": {
                "azdata_cell_guid": "3cfe1728-33cf-4416-bb1c-157c4cd910b4"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SET NOCOUNT ON\r\n",
                "\r\n",
                "-- Cerca tutti gli impiegati il cui cognome inizi per \"D\".\r\n",
                "SELECT empid, lastname\r\n",
                "FROM TSQLV4.HR.Employees\r\n",
                "WHERE lastname LIKE N'D%';\r\n",
                "\r\n",
                "-- Cerca tutti gli impiegati il cui cognome abbia come seconda lettera \"e\".\r\n",
                "SELECT empid, lastname\r\n",
                "FROM TSQLV4.HR.Employees\r\n",
                "WHERE lastname LIKE N'_e%';\r\n",
                "\r\n",
                "-- Cerca tutti gli impiegati il cui cognome inizi per A, B o C. \r\n",
                "SELECT empid, lastname\r\n",
                "FROM TSQLV4.HR.Employees\r\n",
                "WHERE lastname LIKE N'[ABC]%';\r\n",
                "\r\n",
                "-- Cerca tutti gli impiegati le cui iniziali del cognome siano una lettera compresa fra A ed E.\r\n",
                "SELECT empid, lastname\r\n",
                "FROM TSQLV4.HR.Employees\r\n",
                "WHERE lastname LIKE N'[A-E]%';\r\n",
                "\r\n",
                "-- Cerca tutti gli impiegati le cui iniziali del cognome ESCLUDANO i caratteri dalla A alla E.\r\n",
                "SELECT empid, lastname\r\n",
                "FROM TSQLV4.HR.Employees\r\n",
                "WHERE lastname LIKE N'[^A-E]%';"
            ],
            "metadata": {
                "azdata_cell_guid": "a67a0bdb-5365-40db-8f79-296acfaa7ef0",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "# **Lavorare con Date e Ore**\r\n",
                "\r\n",
                "## **Tipi di dati**\r\n",
                "\r\n",
                "T-SQL supporta sei tipi di dati data/ora:\r\n",
                "\r\n",
                "- **DATETIME** (Legacy) — YYYYMMDD hh:mm:ss.nnn, 8 bytes. Monolitico: data e tempo sono inseparabili.\r\n",
                "\r\n",
                "- **SMALLDATETIME** (Legacy) — YYYYMMDD hh:mm, 4 bytes. Monolitico.\r\n",
                "\r\n",
                "- **DATETIME2** — YYYYMMDD/YYYY-MM-DD hh:mm:ss.nnnnnnn, 6-8 bytes. Le  componenti DATE e TIME si possono separare. \r\n",
                "\r\n",
                "- **DATETIMEOFFSET** — YYYYMMDD/YYYY-MM-DD hh:mm:ss.nnnnnnn [+|-] hh:mm. 8-10 bytes. Simile a DATETIME2 ma include il fuso orario rispetto a UTC.\r\n",
                "\r\n",
                "- **DATE** — YYYYMMDD/YYYY-MM-DD. 3 bytes.\r\n",
                "\r\n",
                "- **TIME** — hh:mm:ss.nnnnnnn. 3-5 bytes.\r\n",
                "\r\n",
                " \r\n",
                "## **Codificare un dato DATETIME**\r\n",
                "\r\n",
                "T-SQL non prevede una notazione specifica per codificare un dato DATETIME, bensì si appoggia sulla **conversione, implicita o esplicita, di una stringa**. Ad esempio:\r\n",
                "\r\n",
                "        \r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "89b15aed-5547-42ec-8020-864a06c59013"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "-- Conversione implicita STRING -> DATETIME\r\n",
                "SELECT orderid, custid, empid, orderdate\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "WHERE orderdate = '20160212';"
            ],
            "metadata": {
                "azdata_cell_guid": "11839637-606e-454a-ae7f-a04d0c436457",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "Nel codice qui sopra, T-SQL converte implicitamente la stringa '20160212' ad un dato di tipo DATETIME, poichè la colonna **orderdate** è stata inizializzata con quel tipo di dato. Qualora per chiarezza o robustezza del codice volessimo esplicitare tale conversione, si potrebbe codificare in modo del tutto analogo la seguente query:"
            ],
            "metadata": {
                "azdata_cell_guid": "f4cd13a2-e5e4-46e4-9172-3a5880ec3855"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "-- Conversione esplicita STRING -> DATETIME\r\n",
                "SELECT orderid, custid, empid, orderdate\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "WHERE orderdate = CAST('20160212' AS DATE);"
            ],
            "metadata": {
                "azdata_cell_guid": "dfc68e87-b895-4614-ac8b-11bbaf16b88a",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "Infine, per tutti i tipi che includono sia una componente DATE che una componente TIME, la codifica standard è la seguente:\r\n",
                "\r\n",
                "- **Se non viene specificato TIME** — SQL assume mezzanotte, 00:00:00:...\r\n",
                "\r\n",
                "- **Se non viene specificato alcun fuso/offset UTC** — SQL assume 00:00"
            ],
            "metadata": {
                "azdata_cell_guid": "6285bf11-dfe0-42ac-a350-0d1f1c2d782d"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **Effetti di Localizzazione e Lingua di Sistema sui dati DATETIME**\r\n",
                "\r\n",
                "Le espressioni con DATETIME sono soggette a differenti interpretazioni a seconda della localizzazione e/o della lingua di sistema definita ad ogni login dell'amministratore del database. Tale impostazione, se non esplicitamente cambiata mediante il comando **SET LANGUAGE**, diventa effettiva per la sessione in corso, andando a determinare il senso particolare in cui saranno interpretate le date, se queste sono **NON LANGUAGE NEUTRAL**, come ad esempio **\"02/12/2016\"**, che nel codice seguente viene interpretata differentemente a seconda delle impostazioni linguistiche della sessione. Al contrario, la **notazione standard YYYYMMDD/YYYY-MM-DD** sarà considerata tale a prescidere dal setup."
            ],
            "metadata": {
                "azdata_cell_guid": "a1da5249-d0ff-47c6-9928-a5fffdb98536"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "-- Verrà interpretato come 2 Dicembre, 2016\r\n",
                "SET LANGUAGE British\r\n",
                "SELECT CAST('02/12/2016' AS DATE);\r\n",
                "\r\n",
                "-- Verrà intepretato come 12 Febbraio, 2016\r\n",
                "SET LANGUAGE us_english\r\n",
                "SELECT CAST('02/12/2016' AS DATE);"
            ],
            "metadata": {
                "azdata_cell_guid": "0822f539-dde9-4d2f-b087-1cfca8e0d5d1"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "### **Utilizzare Deliberatamente una Notazione Language-Dependent con CONVERT/PARSE e gli Style Numbers**"
            ],
            "metadata": {
                "azdata_cell_guid": "41fe67d4-ce8e-4dfe-93a4-8c36ee6317d4"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--Dichiara 02/12/2016 come MM/DD/YYYY con lo Style Number 101\r\n",
                "SELECT CONVERT(DATE, '02/12/2016', 101);\r\n",
                "\r\n",
                "--Dichiara 02/12/2016 come DD/MM/YYYY con lo Style Number 101\r\n",
                "SELECT CONVERT(DATE, '02/12/2016', 103);\r\n",
                "\r\n",
                "--ALTO COSTO COMPUTAZIONALE!!! - Dichiara 02/12/2016 come DATE, specificando la cultura en-US\r\n",
                "SELECT PARSE('02/12/2016' AS DATE USING 'en-US');"
            ],
            "metadata": {
                "azdata_cell_guid": "8bc4dd77-baf3-4bcf-8345-84f1bfb2c010",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## **UTC Time Zones in T-SQL**\r\n",
                "\r\n",
                "In T-SQL le informazioni sulle zone UTC sono disponibili nella tabella di sistema **sys.time_zone_info**:"
            ],
            "metadata": {
                "azdata_cell_guid": "643a7295-0c9a-4637-bfe6-9c7895c1f107"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT \r\n",
                "    current_utc_offset AS 'UTC Offset', \r\n",
                "    name AS 'Description', \r\n",
                "    CASE is_currently_dst \r\n",
                "        WHEN 1 THEN 'YES' \r\n",
                "        ELSE 'NO' \r\n",
                "    END AS 'Daylight Saving Right Now?' \r\n",
                "FROM sys.time_zone_info\r\n",
                "ORDER BY current_utc_offset ASC;"
            ],
            "metadata": {
                "azdata_cell_guid": "ba602f48-309e-45bd-97ef-0066efb6dc70"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Filtrare Range di Date con **YEAR/MONTH/DAY(datetime)** e ottimizzare le query per l'indicizzazone\r\n",
                "\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "0561ed05-b560-416a-bad0-dd6b7070afaa"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SET NOCOUNT ON\r\n",
                "\r\n",
                "-- Cerco tutti l'ultimo 10% degli ordini piazzati nell'anno 2015, dal più recente al meno recente.\r\n",
                "SELECT TOP (10) PERCENT orderid, custid, empid, orderdate\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "WHERE YEAR(orderdate) = 2015\r\n",
                "ORDER BY orderid DESC;"
            ],
            "metadata": {
                "azdata_cell_guid": "107cd0d6-319c-4d71-add2-9d15583a5723",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "Tuttavia, usare funzioni per filtrare/manipolare una colonna impedisce a SQL di massimizzare le sue prestazioni utilizzando appropriatamente gli indici. Alla luce di ciò, la query precedente può essere riscritta come segue:"
            ],
            "metadata": {
                "azdata_cell_guid": "9fca567d-5083-436e-9adc-f44e670ae52d"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--Query precedente ottimizzata per l'indicizzazione. L'esecuzione è circa 2ms più rapida.\r\n",
                "SELECT TOP (10) orderid, custid, empid, orderdate\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "WHERE (orderdate >= '20150101') AND (orderdate < '20160101')\r\n",
                "ORDER BY orderid DESC;\r\n",
                "\r\n",
                "---------------------------------------------------------------------------------------------------------------------------------\r\n",
                "\r\n",
                "--Query con FUNZIONE, NON ottimizzata per l'indicizzazione, per cercare gli ultimi 10 ordini piazzati a Febbraio 2016 \r\n",
                "SELECT TOP (10) orderid, custid, empid, orderdate\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "WHERE (YEAR(orderdate) = 2016) AND (MONTH(orderdate) = 2)\r\n",
                "ORDER BY orderid DESC;\r\n",
                "\r\n",
                "--Query con FILTRO, ottimizzata per l'indicizzazione, per cercare tutti gli ultimi 10 ordini piazzati a Febbraio 2016\r\n",
                "SELECT TOP (10) orderid, custid, empid, orderdate\r\n",
                "FROM TSQLV4.Sales.Orders\r\n",
                "WHERE (orderdate >= '20160201') AND (orderdate < '20160301')\r\n",
                "ORDER BY orderid DESC;"
            ],
            "metadata": {
                "azdata_cell_guid": "d697a03a-ee4b-42b6-a8ad-57bdd33e1086",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Ottenere **DATE** e **TIME** correnti con **SYSDATETIME()**, **SYSUTCDATETIME()** e **SYSDATETIMEOFFSET()** e altre funzioni\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "9cbb149c-7ab5-4bfd-aadb-046807b143c2"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--FUNZIONI CONSIGLIATE\r\n",
                "SELECT\r\n",
                "    SYSDATETIME() AS 'SYSDATETIME()', --Ritorna DATETIME2, Data e Ora correnti\r\n",
                "    SYSUTCDATETIME() AS 'SYSUTCDATETIME', --Ritorna DATETIME2, Data e Ora correnti al fuso UTC\r\n",
                "    SYSDATETIMEOFFSET() AS 'SYSDATETIMEOFFSET()'; --Ritorna DATETIMEOFFSET, Data e Ora correnti + Fuso Orario rispetto a UTC\r\n",
                "    \r\n",
                "---------------------------------------------------------------------------------------------------\r\n",
                "\r\n",
                "--LEGACY FUNCTIONS\r\n",
                "SELECT\r\n",
                "    GETDATE() AS 'GETDATE()', --Ritorna DATETIME (LEGACY)\r\n",
                "    CURRENT_TIMESTAMP AS 'CURRENT_TIMESTAMP', --Ritorna DATETIME (LEGACY) ma ANSI-standard\r\n",
                "    GETUTCDATE() AS 'GETUTCDATE()'; --Ritorna DATETIME (LEGACY) e fuso UTC"
            ],
            "metadata": {
                "azdata_cell_guid": "ddb66efb-49a4-4da9-8c27-e0abb5eb7512"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Convertire le ore con **SWITCHOFFSET(datetimeoffset, UTC_offset)**\r\n",
                "\r\n",
                "La funzione **SWITCHOFFSET** di convertire un valore DATETIMEOFFSET ad uno specifico fuso orario UTC 'hh:mm' :"
            ],
            "metadata": {
                "azdata_cell_guid": "b645732d-da95-40a6-910f-bec149fd6f53"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--Converte la data/ora di sistema al fuso orario +08:00\r\n",
                "SELECT SWITCHOFFSET(SYSDATETIMEOFFSET(), '+08:00');\r\n",
                "\r\n",
                "--Converte la data/ora di sistema al fuso UTC\r\n",
                "SELECT SWITCHOFFSET(SYSDATETIMEOFFSET(), '+00:00');"
            ],
            "metadata": {
                "azdata_cell_guid": "15beec10-5ca0-40eb-97f2-ffe383a116c0"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Unire DATETIME e UTC da fonti legacy con **TODATETIMEOFFSET(local_datetime_value, UTC_offset)**\r\n",
                "\r\n",
                "Usata in particolare **per migrare dati non-UTC_offset a dati UTC_offset**, TODATETIMEOFFSET unisce (e non converte!) un dato DATETIME/DATETIME2 con un UTC_offset specificato per creare un nuovo dato di tipo DATETIMEOFFSET."
            ],
            "metadata": {
                "azdata_cell_guid": "61dfb69d-38ac-4420-80a5-a4d9e19169cd"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT TODATETIMEOFFSET(SYSDATETIME(), '+08:00');"
            ],
            "metadata": {
                "azdata_cell_guid": "d9895d81-c829-44f5-a787-e05c81dd60ae"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Addizionare date con **DATEADD(datetime_part, n, datetime_value)**\r\n",
                "\r\n",
                "La funzione **DATEADD** consente di aggiungere ***n*** *year, quarter, month, day, week, hour, minute, second, millisecond, microsecond, nanosecond* specificato/i nell'argomento *datetime_part* ad uno specifico valore dato nell'argomento *datetime_value*."
            ],
            "metadata": {
                "azdata_cell_guid": "ae1dbcbe-283e-4a9f-affe-d1166675c8d9"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--Aggiunge un anno alla data odierna\r\n",
                "SELECT DATEADD(year, 1, SYSDATETIMEOFFSET());"
            ],
            "metadata": {
                "azdata_cell_guid": "b6a63a7c-af6d-401f-b457-1f3de46e95c7"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Differenza fra date con **DATEDIFF/DATEDIFF_BIG(datetime_part, datetime1, datetime2)**\r\n",
                "\r\n",
                "Le funzioni **DATEDIFF** e **DATEDIFF_BIG** consentono di calcolare la differenza in year, quarter, month, day, week, hour, minute, second, millisecond, microsecond, nanosecond fra un valore *datetime1* ed un altro *datetime2*. \r\n",
                "\r\n",
                "L'unica differenza fra le due è la grandezza dell'intero resistuito: **INT** se composto di 4 byte o **BIGINT**, se composto da 8 byte. Quest'ultimo pensato per calcoli più grandi come confronti fra piccole unità temporali come millisecondi/microsecondi e via dicendo."
            ],
            "metadata": {
                "azdata_cell_guid": "86fbdc31-95bb-48a0-a87b-6b2d05d78084"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "--Calcola il numero di giorni trascorsi dall'inizio dell'anno 2020\r\n",
                "SELECT DATEDIFF(day, '20200101', SYSDATETIME()) AS \"Giorno dell'anno\";\r\n",
                "\r\n",
                "--Calcola il numero di microsecondi trascorsi dall'inizio dell'anno 2020\r\n",
                "SELECT DATEDIFF_BIG(microsecond, '20200101', SYSDATETIME()) AS \"Microsecondi dall'inizio dell'anno\";"
            ],
            "metadata": {
                "azdata_cell_guid": "be9f1763-1a0f-4300-af3f-80058b035fa9",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Estrarrei il nome di una data con **DATENAME(part, datetime)**\r\n",
                "\r\n",
                ""
            ],
            "metadata": {
                "azdata_cell_guid": "ab518430-0720-494e-a20f-72a8b1270105"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT DATENAME(month, '20200101');"
            ],
            "metadata": {
                "azdata_cell_guid": "fa3677fd-c1a8-4ccf-88bd-e9d83df36017"
            },
            "outputs": [],
            "execution_count": null
        },
        {
            "cell_type": "markdown",
            "source": [
                "## Produrre DATETIME da parti separate: le funzioni **...FROMPARTS(year, month, day, ...)**"
            ],
            "metadata": {
                "azdata_cell_guid": "1e246a18-f8ff-4378-9980-9ab0c2e6cb57"
            }
        },
        {
            "cell_type": "code",
            "source": [
                "SELECT DATEFROMPARTS(2020, 08, 02);\r\n",
                "SELECT DATETIME2FROMPARTS(2020, 08, 02, 23, 00, 00, 00, 00);"
            ],
            "metadata": {
                "azdata_cell_guid": "2201334f-ce93-443e-b81b-4afd856d2d3e",
                "tags": []
            },
            "outputs": [],
            "execution_count": null
        }
    ]
}