docs.csv-spec

//
// CSV spec used by the docs
//

///////////////////////////////
//
// Describe table
//
///////////////////////////////

describeTable
// tag::describeTable
DESCRIBE emp;

       column       |     type      |    mapping    
--------------------+---------------+---------------
birth_date          |TIMESTAMP      |DATE           
dep                 |STRUCT         |NESTED         
dep.dep_id          |VARCHAR        |KEYWORD        
dep.dep_name        |VARCHAR        |TEXT           
dep.dep_name.keyword|VARCHAR        |KEYWORD        
dep.from_date       |TIMESTAMP      |DATE           
dep.to_date         |TIMESTAMP      |DATE           
emp_no              |INTEGER        |INTEGER        
first_name          |VARCHAR        |TEXT           
first_name.keyword  |VARCHAR        |KEYWORD        
gender              |VARCHAR        |KEYWORD        
hire_date           |TIMESTAMP      |DATE           
languages           |TINYINT        |BYTE           
last_name           |VARCHAR        |TEXT           
last_name.keyword   |VARCHAR        |KEYWORD        
salary              |INTEGER        |INTEGER           

// end::describeTable
;

//describeTableAlias
// tag::describeTableAlias
//DESCRIBE employee;

//    column     |     type      
//---------------+---------------

// end::describeTableAlias
//;

//
// Show columns
// 
showColumns
// tag::showColumns
SHOW COLUMNS IN emp;

       column       |     type      |    mapping    
--------------------+---------------+---------------
birth_date          |TIMESTAMP      |DATE           
dep                 |STRUCT         |NESTED         
dep.dep_id          |VARCHAR        |KEYWORD        
dep.dep_name        |VARCHAR        |TEXT           
dep.dep_name.keyword|VARCHAR        |KEYWORD        
dep.from_date       |TIMESTAMP      |DATE           
dep.to_date         |TIMESTAMP      |DATE           
emp_no              |INTEGER        |INTEGER        
first_name          |VARCHAR        |TEXT           
first_name.keyword  |VARCHAR        |KEYWORD        
gender              |VARCHAR        |KEYWORD        
hire_date           |TIMESTAMP      |DATE           
languages           |TINYINT        |BYTE           
last_name           |VARCHAR        |TEXT           
last_name.keyword   |VARCHAR        |KEYWORD        
salary              |INTEGER        |INTEGER       

// end::showColumns
;

//showColumnsInAlias
// tag::showColumnsInAlias
//SHOW COLUMNS FROM employee;

//    column     |     type      
//---------------+---------------
               
// end::showColumnsInAlias
//;

///////////////////////////////
//
// Show Tables
//
///////////////////////////////

showTables
// tag::showTables
SHOW TABLES;

     name      |     type      
---------------+---------------
emp            |BASE TABLE     
employees      |ALIAS          
library        |BASE TABLE 

// end::showTables
;

showTablesLikeExact
// tag::showTablesLikeExact
SHOW TABLES LIKE 'emp';

     name      |     type      
---------------+---------------
emp            |BASE TABLE     

// end::showTablesLikeExact
;

showTablesLikeWildcard
// tag::showTablesLikeWildcard
SHOW TABLES LIKE 'emp%';

     name      |     type      
---------------+---------------
emp            |BASE TABLE     
employees      |ALIAS          

// end::showTablesLikeWildcard
;


showTablesLikeOneChar
// tag::showTablesLikeOneChar
SHOW TABLES LIKE 'em_';

     name      |     type      
---------------+---------------
emp            |BASE TABLE     

// end::showTablesLikeOneChar
;

showTablesLikeMixed
// tag::showTablesLikeMixed
SHOW TABLES LIKE '%em_';

     name      |     type      
---------------+---------------
emp            |BASE TABLE     

// end::showTablesLikeMixed
;

showTablesLikeEscape
schema::name:s|type:s
// tag::showTablesLikeEscape
SHOW TABLES LIKE 'emp!%' ESCAPE '!';

     name      |     type      
---------------+---------------

// end::showTablesLikeEscape
;


showTablesEsMultiIndex
// tag::showTablesEsMultiIndex
SHOW TABLES "*,-l*";

     name      |     type      
---------------+---------------
emp            |BASE TABLE     
employees      |ALIAS

// end::showTablesEsMultiIndex
;

///////////////////////////////
//
// Show Functions
//
///////////////////////////////

showFunctions
// tag::showFunctions
SHOW FUNCTIONS;

      name       |     type      
-----------------+---------------
AVG              |AGGREGATE      
COUNT            |AGGREGATE      
MAX              |AGGREGATE      
MIN              |AGGREGATE      
SUM              |AGGREGATE      
KURTOSIS         |AGGREGATE      
PERCENTILE       |AGGREGATE      
PERCENTILE_RANK  |AGGREGATE      
SKEWNESS         |AGGREGATE      
STDDEV_POP       |AGGREGATE      
SUM_OF_SQUARES   |AGGREGATE      
VAR_POP          |AGGREGATE      
HISTOGRAM        |GROUPING
COALESCE         |CONDITIONAL
GREATEST         |CONDITIONAL
IFNULL           |CONDITIONAL
ISNULL           |CONDITIONAL
LEAST            |CONDITIONAL
NULLIF           |CONDITIONAL
NVL              |CONDITIONAL
CURRENT_TIMESTAMP|SCALAR
DAY              |SCALAR
DAYNAME          |SCALAR
DAYOFMONTH       |SCALAR         
DAYOFWEEK        |SCALAR         
DAYOFYEAR        |SCALAR         
DAY_NAME         |SCALAR         
DAY_OF_MONTH     |SCALAR         
DAY_OF_WEEK      |SCALAR         
DAY_OF_YEAR      |SCALAR         
DOM              |SCALAR         
DOW              |SCALAR         
DOY              |SCALAR         
HOUR             |SCALAR         
HOUR_OF_DAY      |SCALAR         
IDOW             |SCALAR
ISODAYOFWEEK     |SCALAR
ISODOW           |SCALAR
ISOWEEK          |SCALAR
ISOWEEKOFYEAR    |SCALAR
ISO_DAY_OF_WEEK  |SCALAR
ISO_WEEK_OF_YEAR |SCALAR
IW               |SCALAR
IWOY             |SCALAR
MINUTE           |SCALAR         
MINUTE_OF_DAY    |SCALAR         
MINUTE_OF_HOUR   |SCALAR         
MONTH            |SCALAR         
MONTHNAME        |SCALAR         
MONTH_NAME       |SCALAR         
MONTH_OF_YEAR    |SCALAR
NOW              |SCALAR
QUARTER          |SCALAR         
SECOND           |SCALAR         
SECOND_OF_MINUTE |SCALAR         
WEEK             |SCALAR         
WEEK_OF_YEAR     |SCALAR         
YEAR             |SCALAR         
ABS              |SCALAR         
ACOS             |SCALAR         
ASIN             |SCALAR         
ATAN             |SCALAR         
ATAN2            |SCALAR         
CBRT             |SCALAR         
CEIL             |SCALAR         
CEILING          |SCALAR         
COS              |SCALAR         
COSH             |SCALAR         
COT              |SCALAR         
DEGREES          |SCALAR         
E                |SCALAR         
EXP              |SCALAR         
EXPM1            |SCALAR         
FLOOR            |SCALAR         
LOG              |SCALAR         
LOG10            |SCALAR         
MOD              |SCALAR         
PI               |SCALAR         
POWER            |SCALAR         
RADIANS          |SCALAR         
RAND             |SCALAR         
RANDOM           |SCALAR         
ROUND            |SCALAR         
SIGN             |SCALAR         
SIGNUM           |SCALAR         
SIN              |SCALAR         
SINH             |SCALAR         
SQRT             |SCALAR         
TAN              |SCALAR         
TRUNCATE         |SCALAR         
ASCII            |SCALAR         
BIT_LENGTH       |SCALAR         
CHAR             |SCALAR         
CHARACTER_LENGTH |SCALAR         
CHAR_LENGTH      |SCALAR         
CONCAT           |SCALAR         
INSERT           |SCALAR         
LCASE            |SCALAR         
LEFT             |SCALAR         
LENGTH           |SCALAR         
LOCATE           |SCALAR         
LTRIM            |SCALAR         
OCTET_LENGTH     |SCALAR         
POSITION         |SCALAR         
REPEAT           |SCALAR         
REPLACE          |SCALAR         
RIGHT            |SCALAR         
RTRIM            |SCALAR         
SPACE            |SCALAR         
SUBSTRING        |SCALAR         
UCASE            |SCALAR         
CAST             |SCALAR
CONVERT          |SCALAR
DATABASE         |SCALAR
USER             |SCALAR
SCORE            |SCORE

// end::showFunctions
;

showFunctionsLikeExact
// tag::showFunctionsLikeExact
SHOW FUNCTIONS LIKE 'ABS';

     name      |     type      
---------------+---------------
ABS            |SCALAR    

// end::showFunctionsLikeExact
;

showFunctionsLikeWildcard
// tag::showFunctionsLikeWildcard
SHOW FUNCTIONS LIKE 'A%';

     name      |     type      
---------------+---------------
AVG            |AGGREGATE      
ABS            |SCALAR         
ACOS           |SCALAR         
ASIN           |SCALAR         
ATAN           |SCALAR         
ATAN2          |SCALAR
ASCII          |SCALAR     
// end::showFunctionsLikeWildcard
;

showFunctionsLikeChar
// tag::showFunctionsLikeChar
SHOW FUNCTIONS LIKE 'A__';

     name      |     type      
---------------+---------------
AVG            |AGGREGATE      
ABS            |SCALAR         
// end::showFunctionsLikeChar
;

showFunctionsWithPattern
// tag::showFunctionsWithPattern
SHOW FUNCTIONS LIKE '%DAY%';

     name      |     type      
---------------+---------------
DAY            |SCALAR
DAYNAME        |SCALAR
DAYOFMONTH     |SCALAR
DAYOFWEEK      |SCALAR
DAYOFYEAR      |SCALAR
DAY_NAME       |SCALAR
DAY_OF_MONTH   |SCALAR
DAY_OF_WEEK    |SCALAR
DAY_OF_YEAR    |SCALAR
HOUR_OF_DAY    |SCALAR         
ISODAYOFWEEK   |SCALAR
ISO_DAY_OF_WEEK|SCALAR
MINUTE_OF_DAY  |SCALAR         

// end::showFunctionsWithPattern
;

///////////////////////////////
//
// Select
//
///////////////////////////////

selectColumnAlias
// tag::selectColumnAlias
SELECT 1 + 1 AS result;

    result     
---------------
2    

// end::selectColumnAlias
;

selectInline
// tag::selectInline
SELECT 1 + 1;

    1 + 1    
--------------
2      

// end::selectInline
;

selectColumn
// tag::selectColumn
SELECT emp_no FROM emp LIMIT 1;

    emp_no     
---------------
10001   

// end::selectColumn
;

selectQualifiedColumn
// tag::selectQualifiedColumn
SELECT emp.emp_no FROM emp LIMIT 1;

    emp_no     
---------------
10001   

// end::selectQualifiedColumn
;


wildcardWithOrder
// tag::wildcardWithOrder
SELECT * FROM emp LIMIT 1;

     birth_date     |    emp_no     |  first_name   |    gender     |     hire_date      |   languages   |   last_name   |    salary     
--------------------+---------------+---------------+---------------+--------------------+---------------+---------------+---------------
1953-09-02T00:00:00Z|10001          |Georgi         |M              |1986-06-26T00:00:00Z|2              |Facello        |57305 

// end::wildcardWithOrder
;

fromTable
// tag::fromTable
SELECT * FROM emp LIMIT 1;

     birth_date     |    emp_no     |  first_name   |    gender     |     hire_date      |   languages   |   last_name   |    salary     
--------------------+---------------+---------------+---------------+--------------------+---------------+---------------+---------------
1953-09-02T00:00:00Z|10001          |Georgi         |M              |1986-06-26T00:00:00Z|2              |Facello        |57305        
  

// end::fromTable
;

fromTableQuoted
// tag::fromTableQuoted
SELECT * FROM "emp" LIMIT 1;

     birth_date     |    emp_no     |  first_name   |    gender     |     hire_date      |   languages   |   last_name   |    salary     
--------------------+---------------+---------------+---------------+--------------------+---------------+---------------+---------------
1953-09-02T00:00:00Z|10001          |Georgi         |M              |1986-06-26T00:00:00Z|2              |Facello        |57305   

// end::fromTableQuoted
;

fromTableQuoted
// tag::fromTablePatternQuoted
SELECT emp_no FROM "e*p" LIMIT 1;

    emp_no     
---------------
10001   

// end::fromTablePatternQuoted
;

fromTableAlias
// tag::fromTableAlias
SELECT e.emp_no FROM emp AS e LIMIT 1;

    emp_no     
-------------
10001   

// end::fromTableAlias
;

basicWhere
// tag::basicWhere
SELECT last_name FROM emp WHERE emp_no = 10001;

   last_name   
---------------
Facello   

// end::basicWhere
;

///////////////////////////////
//
// Group By
//
///////////////////////////////

groupByColumn
schema::g:s
// tag::groupByColumn
SELECT gender AS g FROM emp GROUP BY gender;

       g       
---------------
null
F
M

// end::groupByColumn
;

groupByOrdinal
schema::gender:s
// tag::groupByOrdinal
SELECT gender FROM emp GROUP BY 1;

    gender     
---------------
null
F              
M   

// end::groupByOrdinal
;

groupByAlias
schema::g:s
// tag::groupByAlias
SELECT gender AS g FROM emp GROUP BY g;

       g       
---------------
null
F              
M  

// end::groupByAlias
;

groupByExpression
// tag::groupByExpression
SELECT languages + 1 AS l FROM emp GROUP BY l;

       l       
---------------
null
2              
3              
4              
5              
6              
 

// end::groupByExpression
;

groupByMulti
schema::g:s|l:i|c:l
// tag::groupByMulti
SELECT gender g, languages l, COUNT(*) c FROM "emp" GROUP BY g, l ORDER BY languages ASC, gender DESC;

       g       |       l       |       c       
---------------+---------------+---------------
M              |null           |7              
F              |null           |3              
M              |1              |9              
F              |1              |4              
null           |1              |2              
M              |2              |11             
F              |2              |5              
null           |2              |3              
M              |3              |11             
F              |3              |6              
M              |4              |11             
F              |4              |6              
null           |4              |1              
M              |5              |8              
F              |5              |9              
null           |5              |4  


// end::groupByMulti
;


groupByAndAgg
schema::g:s|c:i
// tag::groupByAndAgg
SELECT gender AS g, COUNT(*) AS c FROM emp GROUP BY gender;

       g       |       c       
---------------+---------------
null           |10             
F              |33             
M              |57       

// end::groupByAndAgg
;

groupByAndAggExpression
// tag::groupByAndAggExpression
schema::g:s|salary:i
SELECT gender AS g, ROUND((MIN(salary) / 100)) AS salary FROM emp GROUP BY gender;

       g       |    salary     
---------------+---------------
null           |253            
F              |260            
M              |259        
// end::groupByAndAggExpression
;

groupByAndMultipleAggs
schema::g:s|k:d|s:d
// tag::groupByAndMultipleAggs
SELECT gender AS g, KURTOSIS(salary) AS k, SKEWNESS(salary) AS s FROM emp GROUP BY gender;

       g       |        k         |         s         
---------------+------------------+-------------------
null           |2.2215791166941923|-0.03373126000214023
F              |1.7873117044424276|0.05504995122217512 
M              |2.280646181070106 |0.44302407229580243 


// end::groupByAndMultipleAggs
;

groupByImplicitCount
// tag::groupByImplicitCount
SELECT COUNT(*) AS count FROM emp;

     count     
---------------
100 

// end::groupByImplicitCount
;

///////////////////////////////
//
// Having
//
///////////////////////////////

groupByHaving
// tag::groupByHaving
SELECT languages AS l, COUNT(*) AS c FROM emp GROUP BY l HAVING c BETWEEN 15 AND 20;

       l       |       c       
---------------+---------------
1              |15             
2              |19             
3              |17             
4              |18     

// end::groupByHaving
;

groupByHavingMultiple
// tag::groupByHavingMultiple
SELECT MIN(salary) AS min, MAX(salary) AS max, MAX(salary) - MIN(salary) AS diff FROM emp GROUP BY languages HAVING diff - max % min > 0 AND AVG(salary) > 30000;

      min      |      max      |     diff      
---------------+---------------+---------------
28336          |74999          |46663          
25976          |73717          |47741          
29175          |73578          |44403          
26436          |74970          |48534          
27215          |74572          |47357          
25324          |66817          |41493          


// end::groupByHavingMultiple
;

groupByImplicitMultipleAggs
// tag::groupByImplicitMultipleAggs
SELECT MIN(salary) AS min, MAX(salary) AS max, AVG(salary) AS avg, COUNT(*) AS count FROM emp;

      min:i    |      max:i    |      avg:d    |     count:l     
---------------+---------------+---------------+---------------
25324          |74999          |48248.55       |100  

// end::groupByImplicitMultipleAggs
;

groupByHavingImplicitMatch
// tag::groupByHavingImplicitMatch
SELECT MIN(salary) AS min, MAX(salary) AS max FROM emp HAVING min > 25000;

      min      |      max      
---------------+---------------
25324          |74999        

// end::groupByHavingImplicitMatch
;

//groupByHavingImplicitNoMatch
// tag::groupByHavingImplicitNoMatch
//SELECT MIN(salary) AS min, MAX(salary) AS max FROM emp HAVING max > 75000;

//      min      |      max      
//---------------+---------------

// end::groupByHavingImplicitNoMatch
//;

///////////////////////////////
//
// Grouping
//
///////////////////////////////

histogramNumeric
// tag::histogramNumeric
SELECT HISTOGRAM(salary, 5000) AS h FROM emp GROUP BY h;

       h       
---------------
25000          
30000          
35000          
40000          
45000          
50000          
55000          
60000          
65000          
70000

// end::histogramNumeric  
;

histogramNumericExpression
schema::h:i|c:l
// tag::histogramNumericExpression
SELECT HISTOGRAM(salary % 100, 10) AS h, COUNT(*) AS c FROM emp GROUP BY h;

       h       |       c       
---------------+---------------
0              |10             
10             |15             
20             |10             
30             |14             
40             |9              
50             |9              
60             |8              
70             |13             
80             |3              
90             |9    

// end::histogramNumericExpression  
;

histogramDate
schema::h:ts|c:l
// tag::histogramDate
SELECT HISTOGRAM(birth_date, INTERVAL 1 YEAR) AS h, COUNT(*) AS c FROM emp GROUP BY h;


         h          |       c       
--------------------+---------------
null                |10
1951-04-11T00:00:00Z|1
1952-04-05T00:00:00Z|10
1953-03-31T00:00:00Z|10
1954-03-26T00:00:00Z|7
1955-03-21T00:00:00Z|4
1956-03-15T00:00:00Z|4
1957-03-10T00:00:00Z|6
1958-03-05T00:00:00Z|6
1959-02-28T00:00:00Z|9
1960-02-23T00:00:00Z|7
1961-02-17T00:00:00Z|8
1962-02-12T00:00:00Z|6
1963-02-07T00:00:00Z|7
1964-02-02T00:00:00Z|5    

// end::histogramDate
;

expressionOnHistogramNotAllowed-Ignore
// tag::expressionOnHistogramNotAllowed
SELECT MONTH(HISTOGRAM(birth_date), 2)) AS h, COUNT(*) as c FROM emp GROUP BY h ORDER BY h DESC;
// end::expressionOnHistogramNotAllowed

histogramDateExpression
schema::h:i|c:l
// tag::histogramDateExpression
SELECT HISTOGRAM(MONTH(birth_date), 2) AS h, COUNT(*) as c FROM emp GROUP BY h ORDER BY h DESC;

       h       |       c       
---------------+---------------
12             |7              
10             |17             
8              |16             
6              |16             
4              |18             
2              |10             
0              |6              
null           |10 

// end::histogramDateExpression   
;

///////////////////////////////
//
// Date/Time
//
///////////////////////////////


dtIntervalPlusInterval
// tag::dtIntervalPlusInterval
SELECT INTERVAL 1 DAY + INTERVAL 53 MINUTES AS result;

    result     
---------------
+1 00:53:00.0                       

// end::dtIntervalPlusInterval
;


dtDatePlusInterval
// tag::dtDatePlusInterval
SELECT CAST('1969-05-13T12:34:56' AS DATE) + INTERVAL 49 YEARS AS result;

       result       
--------------------
2018-05-13T12:34:56Z
// end::dtDatePlusInterval
;

dtMinusInterval
// tag::dtMinusInterval
SELECT - INTERVAL '49-1' YEAR TO MONTH result;

    result     
---------------
-49-1         

// end::dtMinusInterval
;

dtIntervalMinusInterval
// tag::dtIntervalMinusInterval
SELECT INTERVAL '1' DAY - INTERVAL '2' HOURS AS result;

    result     
---------------
+0 22:00:00.0  
// end::dtIntervalMinusInterval
;


dtDateMinusInterval
// tag::dtDateMinusInterval
SELECT CAST('2018-05-13T12:34:56' AS DATE) - INTERVAL '2-8' YEAR TO MONTH AS result; 

       result       
--------------------
2015-09-13T12:34:56Z
// end::dtDateMinusInterval
;

dtIntervalMul
// tag::dtIntervalMul
SELECT -2 * INTERVAL '3' YEARS AS result;

    result     
---------------
-6-0    
// end::dtIntervalMul
;


///////////////////////////////
//
// Order by
//
///////////////////////////////

orderByBasic
// tag::orderByBasic
SELECT * FROM library ORDER BY page_count DESC LIMIT 5;

     author      |        name        |  page_count   |    release_date    
-----------------+--------------------+---------------+--------------------
Peter F. Hamilton|Pandora's Star      |768            |2004-03-02T00:00:00Z
Vernor Vinge     |A Fire Upon the Deep|613            |1992-06-01T00:00:00Z
Frank Herbert    |Dune                |604            |1965-06-01T00:00:00Z
Alastair Reynolds|Revelation Space    |585            |2000-03-15T00:00:00Z
James S.A. Corey |Leviathan Wakes     |561            |2011-06-02T00:00:00Z



// end::orderByBasic
;

orderByScore
// tag::orderByScore
SELECT SCORE(), * FROM library WHERE MATCH(name, 'dune') ORDER BY SCORE() DESC;

    SCORE()    |    author     |       name        |  page_count   |    release_date    
---------------+---------------+-------------------+---------------+--------------------
2.2886353      |Frank Herbert  |Dune               |604            |1965-06-01T00:00:00Z
1.8893257      |Frank Herbert  |Dune Messiah       |331            |1969-10-15T00:00:00Z
1.6086556      |Frank Herbert  |Children of Dune   |408            |1976-04-21T00:00:00Z
1.4005898      |Frank Herbert  |God Emperor of Dune|454            |1981-05-28T00:00:00Z

// end::orderByScore
;

orderByScoreWithMatch
// tag::orderByScoreWithMatch
SELECT SCORE(), * FROM library WHERE MATCH(name, 'dune') ORDER BY page_count DESC;

    SCORE()    |    author     |       name        |  page_count   |    release_date    
---------------+---------------+-------------------+---------------+--------------------
2.2886353      |Frank Herbert  |Dune               |604            |1965-06-01T00:00:00Z
1.4005898      |Frank Herbert  |God Emperor of Dune|454            |1981-05-28T00:00:00Z
1.6086556      |Frank Herbert  |Children of Dune   |408            |1976-04-21T00:00:00Z
1.8893257      |Frank Herbert  |Dune Messiah       |331            |1969-10-15T00:00:00Z

// end::orderByScoreWithMatch
;

scoreWithMatch
// tag::scoreWithMatch
SELECT SCORE() AS score, name, release_date FROM library WHERE QUERY('dune') ORDER BY YEAR(release_date) DESC;

     score     |       name        |    release_date    
---------------+-------------------+--------------------
1.4005898      |God Emperor of Dune|1981-05-28T00:00:00Z
1.6086556      |Children of Dune   |1976-04-21T00:00:00Z
1.8893257      |Dune Messiah       |1969-10-15T00:00:00Z
2.2886353      |Dune               |1965-06-01T00:00:00Z
// end::scoreWithMatch
;


///////////////////////////////
//
// Limit
//
///////////////////////////////

limitBasic
// tag::limitBasic
SELECT first_name, last_name, emp_no FROM emp LIMIT 1;

  first_name   |   last_name   |    emp_no     
---------------+---------------+---------------
Georgi         |Facello        |10001     

// end::limitBasic
;

///////////////////////////////
//
// Aggregations
//
///////////////////////////////

aggAvg
// tag::aggAvg
SELECT AVG(salary) AS avg FROM emp;

      avg:d      
---------------
48248.55          
// end::aggAvg
;

aggCountStar
// tag::aggCountStar
SELECT COUNT(*) AS count FROM emp;

     count     
---------------
100               
// end::aggCountStar
;

aggCountDistinct
// tag::aggCountDistinct

SELECT COUNT(DISTINCT hire_date) AS hires FROM emp;

     hires      
---------------
99       
// end::aggCountDistinct
;

aggMax
// tag::aggMax
SELECT MAX(salary) AS max FROM emp;

      max     
---------------
74999               
// end::aggMax
;

aggMin
// tag::aggMin
SELECT MIN(salary) AS min FROM emp;

      min     
---------------
25324               
// end::aggMin
;

aggSum
// tag::aggSum
SELECT SUM(salary) AS sum FROM emp;

      sum
---------------
4824855
// end::aggSum
;

aggKurtosis
// tag::aggKurtosis
SELECT MIN(salary) AS min, MAX(salary) AS max, KURTOSIS(salary) AS k FROM emp;

      min      |      max      |        k         
---------------+---------------+------------------
25324          |74999          |2.0444718929142986
// end::aggKurtosis
;

aggPercentile
// tag::aggPercentile
SELECT languages, PERCENTILE(salary, 95) AS "95th" FROM emp 
       GROUP BY languages;

   languages   |      95th       
---------------+-----------------
null           |74999.0          
1              |72790.5          
2              |71924.70000000001
3              |73638.25         
4              |72115.59999999999
5              |61071.7       
// end::aggPercentile
;

aggPercentileRank
// tag::aggPercentileRank
SELECT languages, PERCENTILE_RANK(salary, 65000) AS rank FROM emp GROUP BY languages;

   languages   |      rank       
---------------+-----------------
null           |73.65766569962062
1              |73.7291625157734 
2              |88.88005607010643
3              |79.43662623295829
4              |85.70446389643493
5              |100.0      
// end::aggPercentileRank
;

aggSkewness
// tag::aggSkewness
SELECT MIN(salary) AS min, MAX(salary) AS max, SKEWNESS(salary) AS s FROM emp;

      min      |      max      |        s         
---------------+---------------+------------------
25324          |74999          |0.2707722118423227
// end::aggSkewness
;

aggStddevPop
// tag::aggStddevPop
SELECT MIN(salary) AS min, MAX(salary) AS max, STDDEV_POP(salary) AS stddev 
       FROM emp;

      min      |      max      |      stddev      
---------------+---------------+------------------
25324          |74999          |13765.125502787832
// end::aggStddevPop
;


aggSumOfSquares
// tag::aggSumOfSquares
SELECT MIN(salary) AS min, MAX(salary) AS max, SUM_OF_SQUARES(salary) AS sumsq 
       FROM emp;

      min      |      max      |     sumsq      
---------------+---------------+----------------
25324          |74999          |2.51740125721E11
// end::aggSumOfSquares
;


aggVarPop
// tag::aggVarPop
SELECT MIN(salary) AS min, MAX(salary) AS max, VAR_POP(salary) AS varpop FROM emp;

      min      |      max      |     varpop     
---------------+---------------+----------------
25324          |74999          |1.894786801075E8
// end::aggVarPop
;


///////////////////////////////
//
// String
//
///////////////////////////////

stringAscii
// tag::stringAscii
SELECT ASCII('Elastic');

ASCII(Elastic) 
---------------
69   
// end::stringAscii
;

stringBitLength
// tag::stringBitLength
SELECT BIT_LENGTH('Elastic');

BIT_LENGTH(Elastic)
-------------------
56  
// end::stringBitLength
;

stringChar
// tag::stringChar
SELECT CHAR(69);

   CHAR(69)    
---------------
E        
// end::stringChar
;

stringCharLength
// tag::stringCharLength
SELECT CHAR_LENGTH('Elastic');

CHAR_LENGTH(Elastic)
--------------------
7     
// end::stringCharLength
;

stringConcat
// tag::stringConcat
SELECT CONCAT('Elasticsearch', ' SQL');

CONCAT(Elasticsearch, SQL)
--------------------------
Elasticsearch SQL  
// end::stringConcat
;

stringInsert
// tag::stringInsert
SELECT INSERT('Elastic ', 8, 1, 'search');

INSERT(Elastic ,8,1,search)
---------------------------
Elasticsearch
// end::stringInsert
;

stringLCase
// tag::stringLCase
SELECT LCASE('Elastic');

LCASE(Elastic) 
---------------
elastic    
// end::stringLCase
;

stringLeft
// tag::stringLeft
SELECT LEFT('Elastic',3);

LEFT(Elastic,3)
---------------
Ela    
// end::stringLeft
;

stringLength
// tag::stringLength
SELECT LENGTH('Elastic   ');

LENGTH(Elastic   )
------------------
7     
// end::stringLength
;

stringLocateWoStart
// tag::stringLocateWoStart
SELECT LOCATE('a', 'Elasticsearch');

LOCATE(a,Elasticsearch)
-----------------------
3        
// end::stringLocateWoStart
;

stringLocateWithStart
// tag::stringLocateWithStart
SELECT LOCATE('a', 'Elasticsearch', 5);

LOCATE(a,Elasticsearch,5)
-------------------------
10
// end::stringLocateWithStart
;

stringLTrim
// tag::stringLTrim
SELECT LTRIM('   Elastic');

LTRIM(   Elastic)
-----------------
Elastic   
// end::stringLTrim
;

stringOctetLength
// tag::stringOctetLength
SELECT OCTET_LENGTH('Elastic');

OCTET_LENGTH(Elastic)
-------------------
7  
// end::stringOctetLength
;

stringPosition
// tag::stringPosition
SELECT POSITION('Elastic', 'Elasticsearch');

POSITION(Elastic,Elasticsearch)
-------------------------------
1  
// end::stringPosition
;

stringRepeat
// tag::stringRepeat
SELECT REPEAT('La', 3);

 REPEAT(La,3)  
---------------
LaLaLa      
// end::stringRepeat
;

stringReplace
// tag::stringReplace
SELECT REPLACE('Elastic','El','Fant');

  REPLACE(Elastic,El,Fant)
-----------------------------
Fantastic
// end::stringReplace
;

stringRight
// tag::stringRight
SELECT RIGHT('Elastic',3);

RIGHT(Elastic,3)
----------------
tic    
// end::stringRight
;

stringRTrim
// tag::stringRTrim
SELECT RTRIM('Elastic   ');

RTRIM(Elastic   )
-----------------
Elastic       
// end::stringRTrim
;

stringSpace-Ignore
schema::SPACE(3):s
// tag::stringSpace
SELECT SPACE(3);

   SPACE(3)    
---------------
               
 
// end::stringSpace
;

stringSubString
// tag::stringSubString
SELECT SUBSTRING('Elasticsearch', 0, 7);

SUBSTRING(Elasticsearch,0,7)
----------------------------
Elastic    
// end::stringSubString
;

stringUCase
// tag::stringUCase
SELECT UCASE('Elastic');

UCASE(Elastic) 
---------------
ELASTIC    
// end::stringUCase
;


///////////////////////////////
//
// Cast
//
///////////////////////////////

conversionStringToIntCast
// tag::conversionStringToIntCast
SELECT CAST('123' AS INT) AS int;

      int      
---------------
123    
// end::conversionStringToIntCast
;

conversionIntToStringCast-Ignore
// tag::conversionIntToStringCast
SELECT CAST(123 AS VARCHAR) AS string;

    string     
---------------
123   

// end::conversionIntToStringCast
;

conversionStringToDateCast
// tag::conversionStringToDateCast
SELECT YEAR(CAST('2018-05-19T11:23:45Z' AS TIMESTAMP)) AS year;

     year
---------------
2018
// end::conversionStringToDateCast
;

///////////////////////////////
//
// Convert
//
///////////////////////////////

conversionStringToIntConvertESDataType
// tag::conversionStringToIntConvertESDataType
SELECT CONVERT('123', INTEGER) AS int;

      int
---------------
123
// end::conversionStringToIntConvertESDataType
;

conversionStringToIntConvertODBCDataType
// tag::conversionStringToIntConvertODBCDataType
SELECT CONVERT('123', SQL_INTEGER) AS int;

      int
---------------
123
// end::conversionStringToIntConvertODBCDataType
;


///////////////////////////////
//
// Math
//
///////////////////////////////

mathInlineAbs
// tag::abs
SELECT ABS(-123.5), ABS(55);

  ABS(-123.5)  |    ABS(55)
---------------+---------------
123.5          |55
// end::abs
;

mathInlineAcos
// tag::mathInlineAcos
SELECT ACOS(COS(PI())), PI();

  ACOS(COS(PI))  |       PI
-----------------+-----------------
3.141592653589793|3.141592653589793
// end::mathInlineAcos
;

mathInlineAsin
// tag::mathInlineAsin
SELECT ROUND(DEGREES(ASIN(0.7071067811865475))) AS "ASIN(0.707)", ROUND(SIN(RADIANS(45)), 3) AS "SIN(45)";

  ASIN(0.707)  |    SIN(45)
---------------+---------------
45.0           |0.707
// end::mathInlineAsin
;

mathInlineAtan
// tag::mathInlineAtan
SELECT DEGREES(ATAN(TAN(RADIANS(90))));

DEGREES(ATAN(TAN(RADIANS(90))))
-------------------------------
90.0
// end::mathInlineAtan
;

mathInlineAtan2
// tag::mathInlineAtan2
SELECT ATAN2(5 * SIN(RADIANS(45)), 5 * COS(RADIANS(45))) AS "ATAN2(5*SIN(45), 5*COS(45))", RADIANS(45);

ATAN2(5*SIN(45), 5*COS(45))|   RADIANS(45)
---------------------------+------------------
0.7853981633974483         |0.7853981633974483
// end::mathInlineAtan2
;

mathInlineCbrtWithNegativeValue
// tag::mathInlineCbrtWithNegativeValue
SELECT CBRT(-125.5);

   CBRT(-125.5)
-------------------
-5.0066577974783435
// end::mathInlineCbrtWithNegativeValue
;

mathInlineCeiling
// tag::mathInlineCeiling
SELECT CEIL(125.01), CEILING(-125.99);

 CEIL(125.01)  | CEIL(-125.99)
---------------+---------------
126            |-125
// end::mathInlineCeiling
;

mathInlineCosine
// tag::mathInlineCosine
SELECT COS(RADIANS(180)), POWER(SIN(RADIANS(54)), 2) + POWER(COS(RADIANS(54)), 2) AS pythagorean_identity;

COS(RADIANS(180))|pythagorean_identity
-----------------+--------------------
-1.0             |1.0
// end::mathInlineCosine
;

mathInlineCosh
// tag::mathInlineCosh
SELECT COSH(5), (POWER(E(), 5) + POWER(E(), -5)) / 2 AS "(e^5 + e^-5)/2";

     COSH(5)     | (e^5 + e^-5)/2
-----------------+-----------------
74.20994852478785|74.20994852478783
// end::mathInlineCosh
;

mathInlineCotangent
// tag::mathInlineCotangent
SELECT COT(RADIANS(30)) AS "COT(30)", COS(RADIANS(30)) / SIN(RADIANS(30)) AS "COS(30)/SIN(30)";

     COT(30)      | COS(30)/SIN(30)
------------------+------------------
1.7320508075688774|1.7320508075688776
// end::mathInlineCotangent
;

mathInlineDegrees
// tag::mathInlineDegrees
SELECT DEGREES(PI() * 2), DEGREES(PI());

DEGREES((PI) * 2)|  DEGREES(PI)
-----------------+---------------
360.0            |180.0
// end::mathInlineDegrees
;

mathEulersNumber
// tag::mathEulersNumber
SELECT E(), CEIL(E());

        E        |    CEIL(E)
-----------------+---------------
2.718281828459045|3
// end::mathEulersNumber
;

mathExpInline
// tag::mathExpInline
SELECT EXP(1), E(), EXP(2), E() * E();

     EXP(1)      |        E        |     EXP(2)     |     (E) * (E)
-----------------+-----------------+----------------+------------------
2.718281828459045|2.718281828459045|7.38905609893065|7.3890560989306495
// end::mathExpInline
;

mathExpm1Inline
// tag::mathExpm1Inline
SELECT E(), EXP(2), EXPM1(2);

        E        |     EXP(2)     |    EXPM1(2)
-----------------+----------------+----------------
2.718281828459045|7.38905609893065|6.38905609893065
// end::mathExpm1Inline
;

mathInlineFloor
// tag::mathInlineFloor
SELECT FLOOR(125.01), FLOOR(-125.99);

 FLOOR(125.01) |FLOOR(-125.99)
---------------+---------------
125            |-126
// end::mathInlineFloor
;

mathInlineLog
// tag::mathInlineLog
SELECT EXP(3), LOG(20.085536923187668);

      EXP(3)      |LOG(20.085536923187668)
------------------+-----------------------
20.085536923187668|3.0
// end::mathInlineLog
;

mathInlineLog10
// tag::mathInlineLog10
SELECT LOG10(5), LOG(5)/LOG(10);

     LOG10(5)     |(LOG(5)) / (LOG(10))
------------------+--------------------
0.6989700043360189|0.6989700043360187
// end::mathInlineLog10
;

mathPINumber
// tag::mathPINumber
SELECT PI();

       PI
-----------------
3.141592653589793
// end::mathPINumber
;

mathInlinePowerPositive
// tag::mathInlinePowerPositive
SELECT POWER(3, 2), POWER(3, 3);

  POWER(3,2)   |  POWER(3,3)
---------------+---------------
9.0            |27.0
// end::mathInlinePowerPositive
;

mathInlinePowerNegative
// tag::mathInlinePowerNegative
SELECT POWER(5, -1), POWER(5, -2);

  POWER(5,-1)  |  POWER(5,-2)
---------------+---------------
0.2            |0.04
// end::mathInlinePowerNegative
;

mathInlineRadians
// tag::mathInlineRadians
SELECT RADIANS(90), PI()/2;

   RADIANS(90)    |     (PI) / 2
------------------+------------------
1.5707963267948966|1.5707963267948966
// end::mathInlineRadians
;

mathRandom
// tag::mathRandom
SELECT RANDOM(123);

   RANDOM(123)
------------------
0.7231742029971469
// end::mathRandom
;

mathRoundWithNegativeParameter
// tag::mathRoundWithNegativeParameter
SELECT ROUND(-345.153, -1) AS rounded;

    rounded
---------------
-350.0
// end::mathRoundWithNegativeParameter
;

mathRoundWithPositiveParameter
// tag::mathRoundWithPositiveParameter
SELECT ROUND(-345.153, 1) AS rounded;

    rounded
---------------
-345.2
// end::mathRoundWithPositiveParameter
;

mathInlineSign
// tag::mathInlineSign
SELECT SIGN(-123), SIGN(0), SIGN(415);

  SIGN(-123)   |    SIGN(0)    |   SIGN(415)
---------------+---------------+---------------
-1             |0              |1
// end::mathInlineSign
;

mathInlineSine
// tag::mathInlineSine
SELECT SIN(RADIANS(90)), POWER(SIN(RADIANS(67)), 2) + POWER(COS(RADIANS(67)), 2) AS pythagorean_identity;

SIN(RADIANS(90))|pythagorean_identity
----------------+--------------------
1.0             |1.0
// end::mathInlineSine
;

mathInlineSinh
// tag::mathInlineSinh
SELECT SINH(5), (POWER(E(), 5) - POWER(E(), -5)) / 2 AS "(e^5 - e^-5)/2";

     SINH(5)     | (e^5 - e^-5)/2
-----------------+-----------------
74.20321057778875|74.20321057778874
// end::mathInlineSinh
;

mathInlineSqrt
// tag::mathInlineSqrt
SELECT SQRT(EXP(2)), E(), SQRT(25);

  SQRT(EXP(2))   |        E        |   SQRT(25)
-----------------+-----------------+---------------
2.718281828459045|2.718281828459045|5.0
// end::mathInlineSqrt
;

mathInlineTanget
// tag::mathInlineTanget
SELECT TAN(RADIANS(66)) AS "TAN(66)", SIN(RADIANS(66))/COS(RADIANS(66)) AS "SIN(66)/COS(66)=TAN(66)";

     TAN(66)      |SIN(66)/COS(66)=TAN(66)
------------------+-----------------------
2.2460367739042164|2.246036773904216
// end::mathInlineTanget
;

mathTruncateWithNegativeParameter
// tag::mathTruncateWithNegativeParameter
SELECT TRUNCATE(-345.153, -1) AS trimmed;

    trimmed
---------------
-340.0
// end::mathTruncateWithNegativeParameter
;

mathTruncateWithPositiveParameter
// tag::mathTruncateWithPositiveParameter
SELECT TRUNCATE(-345.153, 1) AS trimmed;

    trimmed
---------------
-345.1
// end::mathTruncateWithPositiveParameter
;

///////////////////////////////
//
// Null handling
//
///////////////////////////////

coalesceReturnNonNull
// tag::coalesceReturnNonNull
SELECT COALESCE(null, 'elastic', 'search') AS "coalesce";

    coalesce
---------------
elastic
// end::coalesceReturnNonNull
;


coalesceReturnNull
// tag::coalesceReturnNull
SELECT COALESCE(null, null, null, null) AS "coalesce";

    coalesce
---------------
null
// end::coalesceReturnNull
;

ifNullReturnFirst
// tag::ifNullReturnFirst
SELECT IFNULL('elastic', null) AS "ifnull";

    ifnull
---------------
elastic
// end::ifNullReturnFirst
;


ifNullReturnSecond
// tag::ifNullReturnSecond
SELECT IFNULL(null, 'search') AS "ifnull";

    ifnull
---------------
search
// end::ifNullReturnSecond
;

isNullReturnFirst
// tag::isNullReturnFirst
SELECT ISNULL('elastic', null) AS "isnull";

    isnull
---------------
elastic
// end::isNullReturnFirst
;


isNullReturnSecond
// tag::isNullReturnSecond
SELECT ISNULL(null, 'search') AS "isnull";

    isnull
---------------
search
// end::isNullReturnSecond
;

nvlReturnFirst
// tag::nvlReturnFirst
SELECT NVL('elastic', null) AS "nvl";

    nvl
---------------
elastic
// end::nvlReturnFirst
;


nvlReturnSecond
// tag::nvlReturnSecond
SELECT NVL(null, 'search') AS "nvl";

    nvl
---------------
search
// end::nvlReturnSecond
;


nullIfReturnFirst
// tag::nullIfReturnFirst
SELECT NULLIF('elastic', 'search') AS "nullif";
    nullif
---------------
elastic
// end::nullIfReturnFirst
;


nullIfReturnNull
// tag::nullIfReturnNull
SELECT NULLIF('elastic', 'elastic') AS "nullif";

    nullif:s
---------------
null
// end::nullIfReturnNull
;

greatestReturnNonNull
// tag::greatestReturnNonNull
SELECT GREATEST(null, 1, 2) AS "greatest";

    greatest
---------------
2
// end::greatestReturnNonNull
;


greatestReturnNull
// tag::greatestReturnNull
SELECT GREATEST(null, null, null, null) AS "greatest";

    greatest
---------------
null
// end::greatestReturnNull
;

leastReturnNonNull
// tag::leastReturnNonNull
SELECT LEAST(null, 2, 1) AS "least";

    least
---------------
1
// end::leastReturnNonNull
;


leastReturnNull
// tag::leastReturnNull
SELECT LEAST(null, null, null, null) AS "least";

    least
---------------
null
// end::leastReturnNull
;

nullEqualsCompareWithNull
// tag::nullEqualsCompareWithNull
SELECT 'elastic' <=> null AS "equals";

    equals
---------------
false
// end::nullEqualsCompareWithNull
;

nullEqualsCompareTwoNulls
// tag::nullEqualsCompareTwoNulls
SELECT null <=> null AS "equals";

    equals
---------------
true
// end::nullEqualsCompareTwoNulls
;

///////////////////////////////
//
// System functions
//
///////////////////////////////

// ignored because tests run with a docs-not-worthy cluster name
// at the time of this test being ignored, the cluster name was x-pack_plugin_sql_qa_single-node_integTestCluster
database-Ignore
// tag::database
SELECT DATABASE();

   DATABASE
---------------
elasticsearch
// end::database
;

// ignored because tests run with a docs-not-worthy user name
// at the time of this test being ignored, there was no user name being used
user-Ignore
// tag::user
SELECT USER();

     USER
---------------
elastic
// end::user
;

///////////////////////////////
//
// Date-Time functions
//
///////////////////////////////

constantYear
// tag::year
SELECT YEAR(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS year;

     year
---------------
2018
// end::year
;

constantMonthOfYear
// tag::monthOfYear
SELECT MONTH_OF_YEAR(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS month;

     month
---------------
2
// end::monthOfYear
;

constantIsoWeekOfYear
// tag::isoWeekOfYear
SELECT ISO_WEEK_OF_YEAR(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS week;

     week
---------------
8
// end::isoWeekOfYear
;

// Ignored because of https://github.com/elastic/elasticsearch/issues/33796
constantDayName-Ignore
// tag::dayName
SELECT DAY_NAME(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS day;

      day
---------------
Monday
// end::dayName
;


// Ignored because of https://github.com/elastic/elasticsearch/issues/33796
constantMonthName-Ignore
// tag::monthName
SELECT MONTH_NAME(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS month;

     month
---------------
February
// end::monthName
;

constantDayOfYear
// tag::dayOfYear
SELECT DAY_OF_YEAR(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS day;

      day
---------------
50
// end::dayOfYear
;

extractDayOfYear
// tag::extractDayOfYear
SELECT EXTRACT(DAY_OF_YEAR FROM CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS day;

      day
---------------
50
// end::extractDayOfYear
;

constantDayOfMonth
// tag::dayOfMonth
SELECT DAY_OF_MONTH(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS day;

      day
---------------
19
// end::dayOfMonth
;

constantDayOfWeek
// tag::dayOfWeek
SELECT DAY_OF_WEEK(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS day;

      day
---------------
2
// end::dayOfWeek
;

constantIsoDayOfWeek
// tag::isoDayOfWeek
SELECT ISO_DAY_OF_WEEK(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS day;

      day
---------------
1
// end::isoDayOfWeek
;

constantHourOfDay
// tag::hourOfDay
SELECT HOUR_OF_DAY(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS hour;

     hour
---------------
10
// end::hourOfDay
;

constantMinuteOfDay
// tag::minuteOfDay
SELECT MINUTE_OF_DAY(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS minute;

    minute
---------------
623
// end::minuteOfDay
;

constantMinuteOfHour
// tag::minuteOfHour
SELECT MINUTE_OF_HOUR(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS minute;

    minute
---------------
23
// end::minuteOfHour
;

constantSecondOfMinute
// tag::secondOfMinute
SELECT SECOND_OF_MINUTE(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS second;

    second
---------------
27
// end::secondOfMinute
;

constantQuarter
// tag::quarter
SELECT QUARTER(CAST('2018-02-19T10:23:27Z' AS TIMESTAMP)) AS quarter;

    quarter
---------------
1
// end::quarter
;

constantWeekOfYear
// tag::weekOfYear
SELECT WEEK(CAST('1988-01-05T09:22:10Z' AS TIMESTAMP)) AS week, ISOWEEK(CAST('1988-01-05T09:22:10Z' AS TIMESTAMP)) AS isoweek;

      week     |   isoweek
---------------+---------------
2              |1
// end::weekOfYear
;


currentNow
// tag::filterNow
SELECT first_name FROM emp WHERE hire_date > NOW() - INTERVAL 100 YEARS ORDER BY first_name ASC LIMIT 5;

  first_name   
---------------
Alejandro      
Amabile        
Anneke         
Anoosh         
Arumugam       
// end::filterNow
;

currentTimestamp-Ignore
// tag::curTs
SELECT CURRENT_TIMESTAMP AS result;

         result         
------------------------
2018-12-12T14:48:52.448Z
// end::curTs
;

currentTimestampFunction-Ignore
// tag::curTsFunction
SELECT CURRENT_TIMESTAMP() AS result;

         result         
------------------------
2018-12-12T14:48:52.448Z
// end::curTsFunction
;

currentTimestampFunctionPrecision-Ignore
// tag::curTsFunctionPrecision
SELECT CURRENT_TIMESTAMP(1) AS result;

         result         
------------------------
2018-12-12T14:48:52.4Z
// end::curTsFunctionPrecision
;


nowFunction-Ignore
// tag::nowFunction
SELECT NOW() AS result;

         result         
------------------------
2018-12-12T14:48:52.448Z
// end::nowIgnore
;