smoka smokov's questions

Estou tentando fazer uma consulta em loop para o agente Sql que verifica os dados dos usuários e se os critérios forem atendidos a recompensa é enviada, após isso excluiria os registros da tabela reiniciando o loop. O problema é que não consigo fazer o loop funcionar.

Minha mesa fica assim:

ID | login_id | price     |    date    |
1      user1      -100       01/01/1999   

O que eu tentei:

DECLARE @retVal int
SELECT  @retVal = COUNT(*)
select x.login_id, x.price
FROM Table as x inner join Table as b on x.login_id=b.login_id 
where x.price='-100'
order by x.login_id

IF (@retVal >= 3)
BEGIN

DELETE TOP (3) x 
FROM point_log_pitty as x 
inner join point_log_pitty as b on x.login_id=b.login_id 
where b.login_id=x.login_id and @retVal = 3 and x.price='-100';
End

O primeiro problema é que ele conta todos os registros para condições definidas (vários usuários), não por usuário. Exemplo do que tenho (não se limita a apenas 1 usuário):

ID | login_id | price     |    date    |
1      user1      -100       01/01/1999   
2      user2      -100       01/01/1999   
3      user3      -100       01/01/1999   

Eu tentei este também:

SELECT login_id, COUNT(login_id) AS username_count
FROM point_log_pitty
where price='-100'
GROUP BY login_id

O que conta corretamente os registros, mas não posso usar os resultados de username_count para excluir a consulta.

Objetivo: seria mais ou menos assim: Quando seu usuário x atingir 3'-100' de correspondência de preços, a consulta será executada e selecionará os registros do histórico do usuário que correspondem aos critérios e excluirá esses registros, reiniciando o loop.

Esses dados estão sendo buscados e excluídos.

ID | login_id | price     |    date    |
1      user1      -100       01/01/1999   
2      user1      -100       01/01/1999   
3      user1      -100       01/01/1999   

É possível adaptar isso na consulta de atualização que deve buscar uma sequência livre de 3 bytes ou (0x000000) e substituí-la por uma nova sequência se os dados forem divididos assim a cada 3 bytes? O problema é que converter/substituir não funcionará com dados indefinidos que são 0x00. Os dados varbinary são divididos a cada 3bytes -> data(3bytes long)data(3bytes long).

DECLARE @YourTable table
(
Id INT PRIMARY KEY,
Val VARBINARY(50)
)

INSERT @YourTable
VALUES (1, 0x0329000414000B14000C14000D0F00177800224600467800473C00550F00000000000000000000000000),
       (2, 0x0329002637000B14000C14000D0F00177800224600467800473C00550F00000000000000000000000000);


SELECT Id, Triplet
FROM @YourTable T
JOIN (VALUES (1),(4),(7),(10),(13),(16),(19),(22),(25),(28),(31),(34),(37),(40),(43),(46),(49)) Nums(Num) ON Num <= DATALENGTH(T.Val)
CROSS APPLY (VALUES (SUBSTRING(T.Val, Num, 3))) V(Triplet)
WHERE Triplet = 0x000000 and DATALENGTH(Triplet) = 3

O que eu tentei:

UPDATE x    
set  x.column =  CAST(REPLACE(x.column, 0x000000, 0xFFFFFF) AS VARBINARY)
from Table as x 

Funciona apenas se a coluna não contiver dados.

UPDATE x    
set  x.attr =  CAST(REPLACE(0x000000, 0x000000, 0xFFFFFF) 
from Table as x 

Este meio funciona substituindo os primeiros 3 bytes dos dados, mas prefiro não perder dados no processo.

O objetivo é substituir a sequência de dados vazios em varbinary(50) pela sequência do meu desejo. Ou selecione um local específico do binário, por exemplo, o último local plausível do trio e importe/substitua os dados ali pela sequência desejada.

Estou tentando fazer uma consulta que passa por dados varbinary. O problema é que não consigo terminar o que estou tentando alcançar. O que você deve saber sobre a coluna é varbinary(50) e os padrões que ocorrem não têm ordem específica de escrita, o que significa que cada prefixo pode estar em qualquer lugar, desde que tenha 3 bytes (0x000000) O primeiro byte é o prefixo, o segundo e o terceiro são dados de valor que eu estou olhando para verificar se está dentro do intervalo que eu gosto. Todos os dados são escritos assim.

O que eu tentei:

DECLARE @t TABLE (
    val VARBINARY(MAX)
)

INSERT INTO @t SELECT 0x00000100000000000000000000000000000000000000000000000000
INSERT INTO @t SELECT 0x00001000000000000000000000000000000000000000000000000000
INSERT INTO @t SELECT 0x00010000000000000000000000000000000000000000000000000000
INSERT INTO @t SELECT 0x00100000000000000000000000000000000000000000000000000000
INSERT INTO @t SELECT 0x00000f00000000000000000000000000000000000000000000000000

declare @pattern varbinary(max)
declare @pattern2 varbinary(max)
set @pattern = 0x0001
set @pattern2 = @pattern+0xFF

select @pattern,@pattern2

SELECT
    *
FROM @t
WHERE val<@pattern
OR val>@pattern2

Isso foi um fracasso total, os padrões eram precisos até 2 símbolos, se eu usasse 4 símbolos como padrão, funcionaria apenas se o padrão estivesse na posição predefinida. Eu tentei a combinação disso e tudo abaixo.

WHERE CONVERT(varbinary(2), val) = 0xdata

também isso:

select * 
from table
where CONVERT(varchar(max),val,2) like '%data%'

O que funciona muito bem para pesquisar padrões exatos, mas não para intervalos, preciso de uma combinação de ambos.

Eu preciso de algo que detecte isso por conta própria enquanto eu apenas especifico um ponto inicial e final para procurar entre como a maior variação de número seria '26ffff', mas limitá-lo a algo como 'ff00' é aceitável para o que estou procurando por.

Meu melhor palpite é de 2 números definidos, sendo 1 o intervalo máximo permitido e o 2º para um limite, para que não passe por todos os resultados possíveis. Mas eu ficaria feliz em tudo o que funciona.

A origem dos dados está relacionada a um servidor de jogo que armazena os dados dessa forma. Existem os prefixos predefinidos que são o tipo de estatística e o restante dos dados é o valor numérico real da estatística. Os dados são representados por intervalos de dados de 6 caracteres. Aqui está uma amostra do fluxo de dados. É sempre 6-6-6-6-6, desde que haja espaço para gravar os dados, pois é limitado a 50 caracteres. 0x0329000414000B14000C14000D0F00177800224600467800473C00550F00000000000000000000000000

Os grupos estão sempre na moda de 3 bytes, minha ideia é usar o primeiro byte para restringir a pesquisa e usar os segundos 2 bytes para filtrá-lo. Só não sei como fazer isso de maneira eficaz. Se o padrão de 3 bytes for violado, os dados se tornarão ilegíveis, o que significa que, mesmo que você não precise do byte extra, ainda precisará contá-lo, caso contrário, os dados serão quebrados, exemplo de dados em funcionamento.

0x032900'041400'

exemplo de dados corrompidos:

 0x0329'041400'

O único problema que eu poderia pensar é quando o prefixo e parte do valor são verdadeiros exemplo:

0x262600

A menos que a consulta seja especificamente solicitada para ler os dados na sequência de 3 bytes, o que significa que o primeiro byte é sempre um prefixo e os outros 2 bytes são valores.

P: Isso pode ser usado como um indicador de alinhamento para que o primeiro byte diferente de zero após pelo menos 3 bytes zero indique o início de um grupo?

R: Sim, mas isso é improvável, eu quis dizer isso, embora possível, seria escrito em ordem como:

0x260000'270000'

Não pularia para frente um grupo inteiro de 3 bytes preenchido sem dados. Esse tipo de entrada ocorreria se alguém inserisse manualmente no banco de dados, o servidor não faz registros com lacunas como essas que eu saiba:

0x260000'000000'270000'

O mais próximo do meu resultado desejado como uma consulta de trabalho é isso, mas isso é terrível, funcionaria para pequenos intervalos, mas qualquer coisa maior seria tedioso.

select * from @t 
where (CONVERT(varchar(max),val,2) like '%262100%' or 
CONVERT(varchar(max),attr,2) like '%262200%' or 
etc...)

Metas:

1. Localizando o prefixo (primeiro par de dados binários)
2. Definindo um valor máximo após o prefixo, tudo acima desse limite será listado nos resultados. Digamos que '26' seja o prefixo, o maior número permitido depois é '9600' ou '269600'. Basicamente, qualquer dado que exceda esse padrão '269600' deve ser detectado, exemplo '269700'. ou o resultado da consulta postaria isso:

selecione * da tabela onde CONVERT(varchar(max),attr,2) como '%269700%'

Estou tentando obter uma consulta que pode percorrer os dados varbinary de uma tabela que procura um resultado específico dentro do exemplo de parâmetros definidos:

0x263700, os dados são divididos em segmentos de 3 bytes, 1 byte é o cabeçalho que será usado para um padrão de pesquisa, os outros 2 bytes são o valor que tenho que verificar se está dentro do intervalo definido por exemplo: tudo acima de '3700' (+ 1 bit de diferença) o valor binário até 'FFFF' seria classificado como resultado ou o resultado plausível máximo seria '26FFFF'. Isso não é para um fluxo de dados específico ser alternado um por um.

Estou tentando atualizar o tipo do tipo de coluna Titem da tabela e defini-lo como novo id, ao mesmo tempo em que verifique se o id do usuário possui esses 2 itens ( oldid que estamos atualizando, 2º idque é apenas para verificar se o user_id o possui). No entanto, essa é a parte que estou fazendo errado, não sei como usar 1 dos tipos de item, pois é apenas enquanto atualiza o outro, pois ambos compartilham o tipo como referência. Eu sei que estou usando como alguém diria junções antigas, além do que meu objetivo é fazer com que funcione não otimização, não sou desenvolvedor, nem qualquer tipo de codificador. Eu sou um novato com entendimento um pouco básico nada mais. Como tudo está esclarecido agora, eu apreciaria se alguém me desse um exemplo disso funcionando ou como fazê-lo funcionar. Funciona até a parte Exist que é praticamente ignorada. A fila é executada totalmente, no entanto, como eu disse por último, é ignorada. Não há msgs: E é isso que praticamente funciona/é executado:

UPDATE TItem
SET type= 'newid' 
FROM Titem x, TCharacter y
WHERE x.char_id = y.id
and x.type = 'oldid'

table1 'tcharacter'

| id | create date | mode |

Table2 'titem'

| type | Attr | char_ID |

id=char_id Essa é a única coluna em que eles compartilham os mesmos dados Objetivo: SE USER_ID tiver o 3rditem id a fila deve ser executada -> atualizando o id antigo para o newid. Essa é uma maneira de explicar. O que eu tentei abaixo foi tentar atualizar o ID enquanto verificava se user_id tem o 2º itemid presente. O que eu tentei:

UPDATE TItem
SET type= 'newid' 
FROM Titem x, TCharacter y
WHERE x.char_id = y.id
and x.type = 'oldid'
and EXISTS
(SELECT type = '2nd id'  FROM Titem WHERE x.char_id = y.id);

A nova consulta IF que eu tentei está além da crítica de quão confusa ela ficou, o problema é que, independentemente de o item existir ou não, é irrelevante, desde que esteja presente no banco de dados uma vez, o que resulta na fila a ser executada para cada registro adicionando todas as especificações x e y resultou em nada obviamente estou fazendo errado.

IF EXISTS (SELECT 1 FROM Titem as x, TCharacter as y WHERE x.type = '2nd id' AND x.char_id = y.id) 

 BEGIN
     
     UPDATE Titem
SET type =  'mewid'
FROM dbo.TItem AS x, TCharacter AS y
WHERE x.char_id = y.id
and x.type = 'oldid'

     
     
 END