¿Qué consejos generales tienes para jugar al golf en T-SQL? Estoy buscando ideas que se puedan aplicar a los problemas de golf de código en general que sean al menos algo específicos para T-SQL. Por favor, publique un consejo por respuesta.

Gracias a Marcog por la idea original. :)

Mi bolsa general de trucos ::

• @ es una variable válida en t-sql.
• T-sql 2012 agregó iifuna declaración de caso de estilo VB. Esto es casi siempre más corto que un equivalente if else.
• \es una forma útil de inicializar un número como 0 en un tipo de dinero. Puede convertir un valor en un flotante agregando e. por ejemplo, 4eo \kque establecerá k en el valor 0.00 dinero.
• rCTEparece ser la mejor manera de crear una tabla de números de menos de 100 entradas. Incluso más corto que usar spt_values. Si necesita más de un 100, cruce y agregue.
• += y otros operadores compuestos se agregaron en 2008. Úselos para guardar algunos caracteres.
• Los literales suelen ser un delimitador suficientemente bueno para fines de alias. Raramente necesitas un espacio o un ;.
• Utilice las uniones ANSI SQL si las necesita. Select*from A,B where conditiones más corto queselect*from A join b on condition
• Si puede estar seguro de que su bucle while hará la primera iteración, es mejor reescribirlo como un gotobucle de estilo do- while.
• STR()es la función más corta para convertir un int en una cadena. Si está realizando más de una conversión o puede necesitar concatenar numerosos tipos de datos diferentes, considere la concatfunción. Por ejemplo, 'hello'+str(@)es más corto que concat('hello',@), pero hello+str(@)+str(@a)es más largo queconcat('hello',@,@a)

Por ejemplo, estos dos son semánticamente equivalentes.

while @<100begin/*code*/set @+=1 end
s:/*code*/set @+=1if @<100goto s

Puede usar Valuespara crear una tabla o subconsulta. Esto solo será realmente un beneficio si necesita algunas filas constantes.

Compresión de código usando SQL

SQL es prolijo, tiene puntajes altos y, por mucho que los amemos, SELECT FROM WHEREcuesta 23 bytes con cada uso. Puede comprimir estas y otras palabras repetidas o fragmentos de código completos. ¡Hacer esto disminuirá el costo marginal del código repetido a 1 byte! *

Cómo funciona esto:

• Se declara una variable y se le asigna un código SQL comprimido
• Una tabla modifica la variable. Cada fila desinfla la variable.
• La variable modificada se ejecuta.

El problema:

El costo inicial es cercano a 100 bytes y cada fila en la tabla de reemplazo cuesta otros 6 bytes. Este tipo de lógica no será muy efectiva a menos que esté trabajando con un montón de código que no puede recortar o que el desafío esté basado en la compresión.

Aquí hay un ejemplo

El desafío es obtener los últimos 10 múltiplos de 2,3 y 5 que conducen a n. Digamos que esto ( 343 bytes golfed ) es la mejor solución que se me ocurrió:

WITH x AS(
    SELECT 99 n
UNION ALL 
    SELECT n-1
    FROM x
    WHERE n>1
)
SELECT w.n,t.n,f.n
FROM
    (SELECT n, ROW_NUMBER()OVER(ORDER BY n DESC)r
     FROM x WHERE n%2=0
    )w
,
    (SELECT n, ROW_NUMBER()OVER(ORDER BY n DESC)r
     FROM x WHERE n%3=0
    )t
,   (SELECT n, ROW_NUMBER()OVER(ORDER BY n DESC)r
     FROM x WHERE n%5=0
    )f
WHERE w.r=t.r AND w.r=f.r AND w.r<11
ORDER BY 1

Ejemplo después de comprimir el código

Esto ejecuta el mismo código que el anterior, tiene ~ 302 bytes de golf .

DECLARE @a CHAR(999)='
WITH x AS(!99n UNION ALL !n-1 @x#n>1)
!w.n,t.n,f.n@$2=0)w,$3=0)t,$5=0)f
#w.r=t.r AND w.r=f.r AND w.r<11^1'

SELECT @a=REPLACE(@a,LEFT(i,1),SUBSTRING(i,2,99))
FROM(VALUES
  ('$(!n,ROW_NUMBER()OVER(^n DESC)r@x#n%'),
  ('! SELECT '),
  ('@ FROM '),
  ('# WHERE '),
  ('^ ORDER BY ')
)x(i)

EXEC(@a)

Aquí hay uno divertido. Esto convertirá los valores en una columna en una sola tupla.

EDITAR: Gracias por los comentarios. Parece que la forma más corta de enrollar sin las etiquetas XML es:

SELECT (SELECT column1+''
FROM table
ORDER BY column1
FOR XML PATH(''))

Nota: si XML es una salida válida, puede omitir la selección externa y los parens. Además column1+'', solo funciona para cadenas. Para los tipos de números, es mejor hacerlocolumn1+0

Es posible usar algunos operadores bit a bit en T-SQL .

No tengo un ejemplo concreto, pero creo que es bueno saberlo cuando se juega golf en T-SQL.

Imprimir en lugar de Seleccionar

¡Es tan simple como eso! Así que aquí hay un políglota T-SQL / Python:

print'Hello, World!'

Pruébalo en línea

La notación científica es un método más corto para expresar números muy grandes y muy pequeños, por ejemplo, select 1000000000= select 1E9y select 0.000001= select 1E-6.

Michael B mencionó el uso de un CTE recursivo para una tabla numérica , pero no mostró un ejemplo. Aquí hay una versión de MS-SQL que elaboramos en este otro hilo :

--ungolfed
WITH t AS (
    SELECT 1 n 
    UNION ALL 
    SELECT n + 1
    FROM t 
    WHERE n < 99)
SELECT n FROM t

--golfed
WITH t AS(SELECT 1n UNION ALL SELECT n+1FROM t WHERE n<99)SELECT n FROM t

Tenga en cuenta que puede cambiar el valor inicial ( 1 n), el intervalo ( n + 1) y el valor final ( n < 99).

Sin embargo, si necesita más de 100 filas, deberá agregar option (maxrecursion 0):

WITH t AS(SELECT 0n UNION ALL SELECT n+1FROM t WHERE n<9999)
SELECT n FROM t option(maxrecursion 0)

o unirse a la rCTE a sí mismo:

WITH t AS(SELECT 0n UNION ALL SELECT n+1FROM t WHERE n<99)
SELECT 100*z.n+t.n FROM t,t z

Aunque no se garantiza que este último regrese en orden numérico sin un ORDER BY 1

Utilice la compresión GZIP para cadenas muy largas.

Entonces sabía que SQL 2016 agregó una COMPRESSfunción (y una DECOMPRESSfunción), que (finalmente) brinda la capacidad de GZIP una cadena o binario.

El problema es que no está claro de inmediato cómo aprovechar esto para jugar al golf; COMPRESSpuede tomar una cadena pero devuelve un VARBINARY, que es más corto en bytes (cuando se almacena en un VARBINARYcampo SQL ), pero es más largo en caracteres (hexadecimal).

He jugado con esto antes, pero finalmente pude armar una versión funcional, basada en esta vieja respuesta en SO . Esa publicación no usa las nuevas funciones GZIP, pero convierte una VARBINARYcadena codificada en Base-64. Solo necesitábamos insertar las nuevas funciones en el lugar correcto y desarrollarlas un poco.

Aquí está el código que puede usar para convertir su cadena muy larga a la cadena comprimida codificada Base-64:

DECLARE @s VARCHAR(MAX)='Your really long string goes right here'
SELECT CONVERT(VARCHAR(MAX),(SELECT CONVERT(VARBINARY(MAX),COMPRESS(@s))
       FOR XML PATH(''),BINARY BASE64))

Tome la salida y úsela en su código en lugar de la cadena larga original, junto con:

--To use your compressed string and return the original:
DECLARE @e VARCHAR(MAX)='H4sIAAAAAAAEAIvMLy1SKEpNzMmpVMjJz0tXKC4pygRS6fmpxQpFmekZJQoZqUWpAGGwW5YnAAAA'
SELECT CAST(DECOMPRESS(CAST(@e as XML).value('.','varbinary(max)'))AS varchar(max))

Entonces, en lugar de su código original ( 1471 bytes )

SELECT'Four score and seven years ago our fathers brought forth on this continent, a new nation, conceived in Liberty, and dedicated to the proposition that all men are created equal. Now we are engaged in a great civil war, testing whether that nation, or any nation so conceived and dedicated, can long endure. We are met on a great battle-field of that war. We have come to dedicate a portion of that field, as a final resting place for those who here gave their lives that that nation might live. It is altogether fitting and proper that we should do this. But, in a larger sense, we can not dedicate — we can not consecrate — we can not hallow — this ground. The brave men, living and dead, who struggled here, have consecrated it, far above our poor power to add or detract. The world will little note, nor long remember what we say here, but it can never forget what they did here. It is for us the living, rather, to be dedicated here to the unfinished work which they who fought here have thus far so nobly advanced. It is rather for us to be here dedicated to the great task remaining before us — that from these honored dead we take increased devotion to that cause for which they gave the last full measure of devotion — that we here highly resolve that these dead shall not have died in vain — that this nation, under God, shall have a new birth of freedom — and that government of the people, by the people, for the people, shall not perish from the earth.'

tendrías esto ( 1034 bytes ):

SELECT CAST(DECOMPRESS(CAST('H4sIAAAAAAAEAGVUW47bMAy8Cg/g5hD9aLFA0a8C/aYt2hZWEVNJjpGT5LodinE2i/0JIouPmeFQP3QrVCctQpwDVblKpptwqcSLkt3O3FbBeSy6LWujWUtbSTO1NVaaNLeYJbeBmLLslLlFzYNdTBKvEihm+hVHKe029CZBQpy44aYpighdil60RsvDmRtxSnQGEAasqUiPlX8bpxP91p126TeSF168PtNiYTTFa0y0cxmoSQWwhfZVDL8XPsBpAZLb40hVX9B+QgganCkp6kgOW5ET/fXmZ2mmwdF45NaSfJujpEA6ezfg6PErX8FDz2KEj9pIvUBJ63/E92xoBO3xP3Oi8iBxSTyJKY9ArQJSSiAltFhp8IuFEuBXL/TClc7RhmaXJ3prhJFxarq4KHNsvb6RtikcOkHhuuoGLkH7nE/0fcOIu9SJy4LAKrnKYKGmUdb2Qe3++hXSVpnKl+8rpoxh3t1HC9yVw4n+wA9jMVYwwGC4D3xBGOIY89rKtiwJwzINhkPfow0cAagzY8aj4sZMfFG1n90IKnEIZoEgrfDUvOmuBXT3COulaMM0kCieEdgNUOQsZ9gYEB4K8e0BYNwgbHNm2KBik4LCHgmhbxSigz1mYKPcane/Uxyo9D0bDN8oL0vS5/zYlC3DF7Gu+Ay872gQp9U7mDCzb2jPWN0ZaGJKwOJZx3QD9SvD6uEA4l2feHrvnv9lS93ojeu7ScHAAVFGme3tQOr94eGiZwuHSVeFduKDM70avwscZAtd++er+sqrp068VTf5C63D4HBdRfWtvwxcsYq2Ns8a96dvnTxMD7JYH0093+dQxcFU897DhLgO0V+RK0gdlbopj+cCzoRGPxX+89Se5u/dGPtzOIO5SAD5e3drL7LAfiXDyM13HE+d6CWZY26fjr7ZH+cPgFhJzPspK+FpbuvpP9RXxXK3BQAA'as XML).value('.','varbinary(max)'))AS varchar(max))

Vea esta respuesta que me ahorró casi 200 bytes.

No he hecho los cálculos, pero claramente debido a la sobrecarga, esto solo será efectivo para cadenas extremadamente largas. Probablemente hay otros lugares que no se pueden usar; Ya descubrí que tienes que SELECThacerlo, no puedes PRINT, de lo contrario obtienes:

Xml data type methods are not allowed in expressions in this context.

EDITAR : versión más corta del código de descompresión, cortesía de @digscoop :

Ahorre 10 bytes cambiando el exterior CASTa una conversión implícita usando CONCAT:

SELECT CONCAT('',DECOMPRESS(CAST('encoded_string_here'as XML).value('.','varbinary(max)')))

También puede declarar una variable de tipo en XMLlugar de VARCHAR(MAX)y guardar en el interior CAST:

DECLARE @ XML='encoded_string_here'
SELECT CONCAT('',DECOMPRESS(@.value('.','varbinary(max)')))

Esto es un poco más largo por sí solo, pero si lo necesita en una variable por otros motivos, entonces podría ayudar.

Algunas reflexiones sobre la creación y el uso de tablas para desafíos:

1. La entrada SQL se puede tomar a través de una tabla preexistente

Métodos de entrada / salida de golf de código :

Los SQL pueden recibir información de una tabla con nombre

Crear y completar esta tabla con valores de entrada no cuenta para el total de bytes, solo puede suponer que ya está allí.

Esto significa que sus cálculos pueden salir a través de SELECT simple desde la tabla de entrada:

SELECT 2*SQRT(a)FROM t

2. Si es posible, en realidad no cree una tabla

En lugar de (69 bytes):

CREATE TABLE t(b INT)
INSERT t VALUES(7),(14),(21),(99)
SELECT b FROM t

Solo haz (43 bytes):

SELECT b FROM(VALUES(7),(14),(21),(99))t(b)

3. Si es posible, cree la tabla con un SELECCIONAR EN

En lugar de (39 bytes):

CREATE TABLE t(p INT)
INSERT t VALUES(2)

Haga esto (17 bytes):

SELECT 2 p INTO t

4: Considere mezclar varias columnas juntas

Aquí hay dos variaciones que devuelven el mismo resultado:

SELECT a,b FROM
(VALUES('W','Bob'),('X','Sam'),('Y','Darla'),('Z','Elizabeth'))t(a,b)

SELECT LEFT(a,1),SUBSTRING(a,2,99)FROM
(VALUES('WBob'),('XSam'),('YDarla'),('ZElizabeth'))t(a)

Después de algunas pruebas, la versión superior (columnas múltiples) parece más corta con 7 o menos filas , la versión inferior (debido a la IZQUIERDA y SUBSTRING) es más corta con 8 o más filas . Su kilometraje puede variar, dependiendo de sus datos exactos.

5: Use REPLACE y EXEC para secuencias de texto muy largas

En la línea de la excelente respuesta de cómodamentedrei , si tiene 15 o más valores , use REPLACEun símbolo para deshacerse de los '),('separadores repetidos entre elementos:

114 caracteres:

SELECT a FROM(VALUES('A'),('B'),('C'),('D'),('E'),('F'),('G'),('H')
,('I'),('J'),('K'),('L'),('M'),('N'),('O'))t(a)

112 caracteres:

DECLARE @ CHAR(999)=REPLACE('SELECT a FROM(VALUES(''
 A-B-C-D-E-F-G-H-I-J-K-L-M-N-O''))t(a)','-','''),(''')EXEC(@)

Si usted está ya utilizando SQL dinámico por otras razones (o tener múltiples sustituye), entonces el umbral en el que esto vale la pena es mucho menor.

6: Use un SELECT con columnas con nombre en lugar de un montón de variables

Inspirado por la excelente respuesta de jmlt aquí , reutilice las cadenas a través de un SELECCIONAR:

SELECT a+b+a+b+d+b+b+a+a+d+a+c+a+c+d+c+c+a+a
FROM(SELECT'Hare 'a,'Krishna 'b,'Rama 'c,'
'd)t

devoluciones

Hare Krishna Hare Krishna 
Krishna Krishna Hare Hare 
Hare Rama Hare Rama 
Rama Rama Hare Hare 

(Para MS SQL, cambié \ta un retorno en línea y cambié CONCAT()a +para guardar bytes).

Etiquete su código para resaltar la sintaxis de T-SQL

En lugar de solo:

CREATE TABLE t(b INT)
INSERT t VALUES(7),(14),(21),(99)
SELECT b FROM t

Incluya una etiqueta de idioma como esta:

<!-- language: lang-sql -->

    CREATE TABLE t(b INT)
    INSERT t VALUES(7),(14),(21),(99)
    SELECT b FROM t

y el resultado será:

CREATE TABLE t(b INT)
INSERT t VALUES(7),(14),(21),(99)
SELECT b FROM t

Aproveche las nuevas características / funciones en MS SQL 2016 y SQL 2017

Si no tiene copias locales para trabajar, puede jugar en línea con el Explorador de datos de StackExchange (SQL 2016) o con dbfiddle.uk (SQL 2016 o SQL "vNext").

STRING_SPLIT ( SQL 2016 y posterior )

SELECT *
FROM STRING_SPLIT('one,two,three,four,five',',')

Si necesita alias de la tabla o hacer referencia al nombre de la columna:

SELECT t.value
FROM STRING_SPLIT('one,two,three,four,five',',')t

TRIM ( SQL 2017 o posterior )

Más corto que RTRIM()y ciertamente más corto que LTRIM(RTRIM()).

También tiene una opción para eliminar otros caracteres o conjuntos de caracteres desde el principio o el final:

SELECT TRIM('sq,0' FROM 'SQL Server 2000')

devoluciones L Server 2

TRADUCIR ( SQL 2017 o posterior )

TRANSLATEle permite reemplazar varios caracteres en un solo paso, en lugar de un conjunto de REPLACEdeclaraciones anidadas . Pero no celebre demasiado , solo reemplaza caracteres individuales individuales con caracteres individuales diferentes.

SELECT TRANSLATE('2*[3+4]/{7-2}', '[]{}', '()()');

Cada carácter en la segunda cadena se reemplaza por el carácter correspondiente en la tercera cadena.

Parece que podríamos eliminar un montón de personajes con algo como REPLACE(TRANSLATE('source string','ABCD','XXXX'),'X','')

Algunos más interesantes también, como CONCAT_WSy STRING_AGGque probablemente valen la pena también.

Santa vaca, he descubierto la maravilla de PARSENAME( SQL 2012 o superior ).

La función se creó para aislar las partes de un nombre de objeto como servername.dbname.dbo.tablename, pero funciona para cualquier valor separado por puntos. Solo recuerda que cuenta desde la derecha , no desde la izquierda:

SELECT PARSENAME('a.b.c.d',1),      -- d
       PARSENAME('a.b.c.d',2),      -- c
       PARSENAME('a.b.c.d',3),      -- b
       PARSENAME('a.b.c.d',4)       -- a

Si tiene menos de 4 valores separados por puntos, devolverá NULLel resto (pero aún cuenta de derecha a izquierda ):

SELECT PARSENAME('a.b',1),      -- b
       PARSENAME('a.b',2),      -- a
       PARSENAME('a.b',3),      -- NULL
       PARSENAME('a.b',4)       -- NULL

Sin embargo, aquí es donde entra la magia: ¡combínelo con STRING_SPLIT(2016 o superior) para hacer tablas en varias columnas en memoria!

Viejo y roto:

SELECT a,b,c FROM
(VALUES('Bob','W','Smith'),
       ('Sam','X','Johnson'),
       ('Darla','Y','Anderson'),
       ('Elizabeth','Z','Turner'))t(a,b,c)

Nuevo calor:

SELECT PARSENAME(value,3)a,PARSENAME(value,2)b,PARSENAME(value,1)c
FROM string_split('Bob.W.Smith-Sam.X.Johnson-Darla.Y.Anderson-Elizabeth.Z.Turner','-')

Claramente, sus ahorros reales dependen del tamaño y el contenido de la tabla, y de cómo lo está utilizando exactamente.

Tenga en cuenta que si sus campos son de ancho constante, probablemente sea mejor usarlos LEFTy RIGHTsepararlos en lugar de PARSENAME(no solo porque los nombres de las funciones son más cortos, sino también porque puede eliminar los separadores por completo).

Un par de trucos más no relacionados que vi y quise preservar:

1. Use GO #para repetir un bloque un número específico de veces .

Vi este ingenioso truco en la excelente respuesta de Paul .

PRINT'**********'
GO 10

Esto, por supuesto, restablecería cualquier variable de contador en el bloque, por lo que tendría que comparar esto con un WHILEbucle o un x: ... GOTO xbucle.

2. SELECT TOP ... FROM systypes

De la misma pregunta que la anterior de Pablo, Anuj Tripathi usó el siguiente truco :

SELECT TOP 10 REPLICATE('*',10) FROM systypes

o, como lo sugiere pinkfloydx33 en los comentarios:

SELECT TOP 10'**********'FROM systypes

Tenga en cuenta que esto no se basa en ninguno de los contenidos reales de systypes, solo que la vista del sistema existe (que existe en todas las bases de datos MS SQL) y contiene al menos 10 filas (parece contener 34, para las versiones más recientes de SQL ) No pude encontrar ninguna vista del sistema con nombres más cortos (que no requirieran un sys.prefijo), por lo que esto puede ser ideal.

Ver esta pregunta en dba.stackexchange para obtener algunas ideas interesantes para agregar una columna numérica a un resultado de STRING_SPLIT.

Dada una cadena como 'one,two,three,four,five', queremos obtener algo como:

value   n
------ ---
one     1
two     2
three   3
four    4
five    5

1. Según la respuesta de Joe Obbish, use ROW_NUMBER()y ordene por NULLo una constante:

   SELECT value, ROW_NUMBER() OVER(ORDER BY (SELECT 1))n
   FROM STRING_SPLIT('one,two,three,four,five',',')
   

2. Según la respuesta de Paul White, use unSEQUENCE :

   CREATE SEQUENCE s START WITH 1
   SELECT value, NEXT VALUE FOR s 
   FROM STRING_SPLIT('one,two,three,four,five', ',')
   

Las secuencias son interesantes objetos persistentes; puede definir el tipo de datos, el valor mínimo y máximo, el intervalo y si se ajusta al principio:

    CREATE SEQUENCE s TINYINT;     --Starts at 0
    CREATE SEQUENCE s MINVALUE 1;  --Shorter than START WITH
    SELECT NEXT VALUE FOR s        --Retrieves the next value from the sequence
    ALTER SEQUENCE s RESTART;      --Restarts a sequence to its original start value

3. Según la respuesta de Biju jose, puede usar la IDENTITY() función (que no es lo mismo que la IDENTITY propiedad junto con un INSERT:

   SELECT value v,IDENTITY(INT) AS n
   INTO t
   FROM STRING_SPLIT('one,two,three,four,five',',')
   
   SELECT * FROM t
   

Tenga en cuenta que los dos últimos parámetros en IDENTITY(INT,1,1)son opcionales y su valor predeterminado será 1 si se excluye.

Acabo de descubrir que puedes usar números para un solo carácter REPLACEpara eliminar comillas :

--44 bytes
PRINT REPLACE('Baby Shark******','*',' doo')

--42 bytes
PRINT REPLACE('Baby Shark000000',0,' doo')

Esto es porque REPLACE hace una conversión implícita a cadena.

Ambos producen la misma salida:

Baby Shark doo doo doo doo doo doo

_ y # son alias válidos. Los uso con CROSS APPLY para que parezca que las columnas que devuelve son parte de la cláusula FROM, por ejemplo

SELECT TOP 10 number, n2
FROM master.dbo.spt_values v
CROSS APPLY (SELECT number*2 n2) _

Me gusta cuando el único propósito de CROSS APPLY es calcular una expresión.

Para el caso, usar APPLY para calcular subexpresiones es una buena manera de hacer que su código sea SECO (y más corto). Por lo que he visto en los planes de ejecución, este enfoque no tiene un costo adicional. El compilador se da cuenta de que solo estás calculando algo y lo trata como cualquier otra expresión.