Eu tenho duas mesas:

empregos

CREATE TABLE IF NOT EXISTS jobs (
    job_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
    job_name TEXT,
    prime_desc INTEGER NOT NULL REFERENCES descriptions(desc_id),
    scnd_desc INTEGER NOT NULL REFERENCES descriptions(desc_id),
);

INSERT INTO jobs (job_name, prime_desc, scnd_desc) VALUES ('Soldier', 1, 5);
INSERT INTO jobs (job_name, prime_desc, scnd_desc) VALUES ('Pastor', 2, 3);
INSERT INTO jobs (job_name, prime_desc, scnd_desc) VALUES ('Firefighter', 5, 4);

descrições

CREATE TABLE IF NOT EXISTS descriptions (
    desc_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
    desc_name TEXT,
);

INSERT INTO descriptions (desc_name) VALUES ('Strong');
INSERT INTO descriptions (desc_name) VALUES ('Pious');
INSERT INTO descriptions (desc_name) VALUES ('Honest');
INSERT INTO descriptions (desc_name) VALUES ('Agile');
INSERT INTO descriptions (desc_name) VALUES ('Brave');

Neste exemplo, gostaria de poder adicionar duas descrições a um trabalho. O código funciona e posso consultá-lo:

SELECT * FROM jobs;

Isso retorna o resultado esperado:

1|Soldier|1|5
2|Pastor|2|3
3|Firefighter|5|4

O que estou tentando fazer é obter uma consulta que liste o nome do trabalho e os nomes das descrições primária e secundária:

Firefighter|Brave|Agile

Não consegui obter esse resultado.

Eu tentei:

SELECT
    jobs.job_name,
    desc.desc_name
FROM
    jobs
JOIN
    descriptions ON jobs.prime_desc = descriptions.desc_id
JOIN
    descriptions ON jobs.scnd_desc = descriptions.desc_id;

Isso retorna um erro:

Parse error: ambiguous column name: descriptions.desc_name
  SELECT jobs.job_name, descriptions.desc_name FROM jobs JOIN descriptions ON...
          error here ---^

Pesquisei na Internet sobre esse erro e não consegui encontrar nada que fosse um exemplo do que estou tentando realizar.

Eu tentei muitas combinações diferentes de:

RIGHT JOIN, LEFT JOIN, UNION, UNION ALL, ALIAS

em múltiplas configurações. O mais próximo que cheguei foi com UNION, mas não produziu os resultados desejados; aqui está o UNION que tentei:

SELECT
    jobs.job_name, descriptions.desc_name
FROM
    jobs
JOIN
    descriptions ON jobs.prime_desc = descriptions.desc_id
UNION
SELECT
    jobs.job_name, descriptions.desc_name
FROM
    jobs
JOIN
    descriptions ON jobs.scnd_desc = descriptions.desc_id;

Isso retorna:

Soldier|Strong
Pastor|Pious
Firefighter|Brave
Soldier|Brave
Pastor|Honest
Firefighter|Agile

Ele está retornando os resultados conforme solicitado, então sei que é algo que estou fazendo de errado. Só não sei o que estou fazendo que não imprime os resultados em uma linha por trabalho, conforme ilustrado pelo exemplo do Bombeiro acima.

Tentei criar um alias de coluna, um alias de tabela etc. Não sei como abordar isso. Qualquer ajuda é apreciada.

Quero poder obter dados da tabela que possui a chave estrangeira como chave primária, usando apenas os dados da WHEREcláusula da outra tabela.

Eu tentei uma junção interna e estou obtendo resultados estranhos. Estou usando https://sqliteonline.com para testar isso.

Eu tenho duas tabelas, uma chamada carsque tem nome e ID. Aquele que é chamado logged_datae possui um ID, faixa e ID do carro que é uma chave estrangeira usando car.id.

Quero obter todos os nomes de carros (distintos) que possuem dados registrados em uma pista específica.

Estas são as declarações que tentei:

CREATE TABLE cars (id INTEGER PRIMARY KEY NOT NULL, name TEXT UNIQUE NOT NULL DEFAULT 'Car1');
INSERT INTO cars DEFAULT VALUES;
INSERT OR IGNORE INTO cars (name) VALUES ("BMW");
INSERT OR IGNORE INTO cars (name) VALUES ("test");
CREATE TABLE logged_data (id INTEGER PRIMARY KEY NOT NULL, track TEXT NOT NULL, car_id INTEGER NOT NULL, FOREIGN KEY(car_id) REFERENCES cars(id) ON DELETE CASCADE);
INSERT INTO logged_data (track, car_id) VALUES ("track", (SELECT id FROM cars WHERE name = "Car1"));
INSERT INTO logged_data (track, car_id) VALUES ("track", (SELECT id FROM cars WHERE name = "Car1"));
INSERT INTO logged_data (track, car_id) VALUES ("track", (SELECT id FROM cars WHERE name = "BMW"));
INSERT INTO logged_data (track, car_id) VALUES ("track", (SELECT id FROM cars WHERE name = "BMW"));
INSERT INTO logged_data (track, car_id) VALUES ("track1", (SELECT id FROM cars WHERE name = "test"));
INSERT INTO logged_data (track, car_id) VALUES ("track1", (SELECT id FROM cars WHERE name = "test"));
SELECT DISTINCT name FROM cars INNER JOIN logged_data ON logged_data.car_id = cars.id WHERE track = "track";

Isso retorna:

Car1
BMW
test

testnão deve ser retornado porque não possui dados registrados em track.

Tentei selecionar tudo para ver como são as tabelas unidas:

SELECT * FROM cars INNER JOIN logged_data ON logged_data.car_id = cars.id WHERE track = "track";

Isso apenas retorna todos os dados de todas as faixas, mesmo que eu tenha solicitado apenas arquivos track.

O que é estranho, porém, é que se eu obtiver nomes de carros distintos com dados registrados em track1. Ele retorna corretamente apenas test. Esta é a abordagem correta para o que eu quero? Por que estou vendo esse comportamento diferente?

SELECT DISTINCT name FROM cars INNER JOIN logged_data ON logged_data.car_id = cars.id WHERE track = "track1";

Isso retorna:

test

Dada uma tabela como esta,

Quero criar uma tabela via SQL sem fazer funções de janela

id | time| attribute1| attribute1atFirstRecordedTimeperID

1  | 0 | a  | a

1 | 2 | b | a

2| 0 | c | c

2| 4 | d | c

tentei

SELECT 
    t1.id, 
    t1.time, 
    t1.attribute1,
    attribute1fixedattime0 = t2.attribute1
FROM s t1
INNER JOIN (
    SELECT attribute1 AS attribute1fixedattime0
    FROM s
    WHERE time = 0
) t2 ON t1.id = t2.id

O alias da coluna está correto?

Isso gera um erro

Se eu corrigir esse código, quero fazer o código SQL funcionar para o caso em que id=2 não tem seu primeiro atributo1 registrado no tempo t=0, mas para t>0. Então faço um min na condição de join ou dentro do JOIN?

Quero criar uma tabela via SQL sem fazer funções de janela para virar

em

Para ir de

identificação | tempo| atributo1

1  | 0 | a 

1 | 2 | b 

2| 42 | c 

2| 69 | d 

para a mesa

id | time| attribute1| attribute1atFirstRecordedTimeperID

1  | 0 | a  | a

1 | 2 | b | a

2| 42 | c | c

2| 69 | d | c

se você usar uma função de janela row_number() para marcar o local em que a primeira vez está dentro de cada id, então como você se junta ou não usaria uma junção, mas algo mais?

SELECT 
    id,
    time,
    attribute1,
    ROW_NUMBER() OVER (PARTITION BY id ORDER BY time) AS rn
FROM your_table

SELECT
    id,
    time,
    attribute1,
    FIRST_VALUE(attribute1) OVER (PARTITION BY id ORDER BY time ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS attribute1atFirstRecordedTimeperID
FROM (
    -- Previous query here
) AS subquery

Eu sinto que este é um problema comum e já vi isso em alguns desafios de SQL, mas pela minha vida, não consigo pensar claramente em uma solução.

Digamos que você tenha uma hierarquia desigual. Elementos que pertencem a outros elementos mas você não conhece o topo.

Digamos que seja um organograma da empresa para mantê-lo simples (na verdade, são dependências de tarefas, mas eh).

Então há uma mesa. Nome do funcionário e nome do chefe.

Employee name: Bob .... Boss Name: Dora
Employee name Dora .... Boss Name: Kim

E assim por diante. No meu caso, há uma informação adicional. Uma pessoa só se reporta a uma pessoa. Relacionamento um para um.

Existem N elementos no topo da cadeia que possuem Nome: Quem quer que seja Chefe: Nulo.

Então eu estava fazendo algo da seguinte forma:

select employee_name, boss_name
from boss_table b1
left join boss_table b2 on b1.boss_name = b2.employee_name
left join boss_table b3 on b2.boss_name = b3.employee_name

E assim por diante para tentar encontrar o 'Chefe Raiz' ou 'Chefe Superior' de cada funcionário. No entanto, alguns desses elementos aninhados são MUITO profundos - não quero fazer 20 junções ... ou pelo menos digitá-los - sinto que uma função recursiva é a resposta óbvia, mas não consigo descobrir - pensamentos?

Tenho duas tabelas com as seguintes colunas:

Table1
id 
Sort
dou

e

Table2
id_Table1
Sort

e preciso ler todos os valores de Table1.Sort onde Table1.dou = 1 e gravá-los em Table2.Sort, nas linhas onde Table2.id_Table1 corresponde aos valores de Table1.id.

Eu posso fazer:SELECT Sort FROM Table1 WHERE dou = 1

E eu posso fazerUPDATE Table2 SET Sort WHERE id_Table1 = 'uuid'

Mas como posso combiná-los de forma que todos os valores Table1.Sort substituam os valores Table2.Sort?

Na minha versão do SQL92 posso usar INNER JOINinstruções, mas não sei até que ponto elas estão de acordo com o padrão. Não tenho ideia de que isso poderia funcionar com uma UPDATEdeclaração.

Estou usando o mecanismo SQL do FileMaker.

Banco de dados SQLite com uma tabela "eventos" com as colunas events.eventDate , events.ageAtEvent e events.foreignKey_participants , e uma tabela "participants" com as colunas participantes.primaryKey e participantes.dob .

Desejo atualizar todas as linhas em events.ageAtEvent com a idade atual no momento do evento para cada participante.

O que eu tentei:

UPDATE events
SET ageAtEvent = (
SELECT (strftime('%Y', events.eventDate) - strftime('%Y', participants.dob)) - (strftime('%m-%d', events.eventDate) < strftime('%m-%d', participants.dob))
FROM events JOIN participants ON events.foreignKey_participants = participants.primaryKey
);

Isso preenche todas as linhas com o mesmo ageAtEvent, presumivelmente o primeiro. Não estou claro como aplicar o cálculo correto a cada linha. Muito grato pela ajuda sobre isso.

Tabela WSHOSHO

SELECT * FROM WSHOSHO;

Tabela RRP

SELECT * FROM RRP;

Junte-se para ilustrar o problema

Os resultados dessa junção podem ser usados ​​para ilustrar o problema:

SELECT * FROM WSHOSHO RIGHT JOIN RRP ON (WSHOSHO.DATE = RRP.DATE);

Resultado:

Ou seja:

For any given row of RRP
    If there's a `WSHOSHO` row with the same date, use that

    Otherwise, use the most recent WSHOSHO before RRP.DATE

Pergunta

O que é uma boa consulta para conseguir isso?

dados de exemplo

Aqui está um código T-SQL para configurar os dados de exemplo usados ​​aqui.

DROP TABLE WSHOSHO;

DROP TABLE RRP;

IF NOT EXISTS (SELECT * FROM sysobjects WHERE name='WSHOSHO')
    CREATE TABLE WSHOSHO (
        DATE    varchar(255), 
        WSHOSHO decimal
    )

IF NOT EXISTS (SELECT * FROM sysobjects WHERE name='RRP')
    CREATE TABLE RRP (
        DATE    varchar(255), 
        RRP decimal
    )

INSERT INTO WSHOSHO
VALUES 
('2023-01-11', 8100175.0), 
('2023-01-18', 8079010.0), 
('2023-01-25', 8062665.0), 
('2023-02-01', 8024470.0), 
('2023-02-08', 8024104.0), 
('2023-02-15', 7990467.0), 
('2023-02-22', 7986887.0), 
('2023-03-01', 7948534.0), 
('2023-03-08', 7948335.0), 
('2023-03-15', 7940014.0), 
('2023-03-22', 7936558.0), 
('2023-03-29', 7926131.0), 
('2023-04-05', 7877114.0);

INSERT INTO RRP
VALUES
('2023-01-03', 2188272000000), 
('2023-01-04', 2229542000000), 
('2023-01-05', 2242486000000), 
('2023-01-06', 2208265000000), 
('2023-01-09', 2199121000000), 
('2023-01-10', 2192942000000), 
('2023-01-11', 2199170000000), 
('2023-01-12', 2202989000000), 
('2023-01-13', 2179781000000), 
('2023-01-17', 2093328000000), 
('2023-01-18', 2131678000000), 
('2023-01-19', 2110145000000), 
('2023-01-20', 2090523000000), 
('2023-01-23', 2135499000000), 
('2023-01-24', 2048386000000), 
('2023-01-25', 2031561000000), 
('2023-01-26', 2024069000000), 
('2023-01-27', 2003634000000), 
('2023-01-30', 2048714000000), 
('2023-01-31', 2061572000000), 
('2023-02-01', 2038262000000), 
('2023-02-02', 2050063000000), 
('2023-02-03', 2041217000000), 
('2023-02-06', 2072261000000), 
('2023-02-07', 2057958000000), 
('2023-02-08', 2059604000000), 
('2023-02-09', 2058942000000), 
('2023-02-10', 2042893000000), 
('2023-02-13', 2107775000000), 
('2023-02-14', 2076548000000), 
('2023-02-15', 2011998000000), 
('2023-02-16', 2032457000000), 
('2023-02-17', 2059662000000), 
('2023-02-21', 2046064000000), 
('2023-02-22', 2113849000000), 
('2023-02-23', 2147417000000), 
('2023-02-24', 2142141000000), 
('2023-02-27', 2162435000000), 
('2023-02-28', 2188035000000), 
('2023-03-01', 2133950000000), 
('2023-03-02', 2192355000000), 
('2023-03-03', 2186150000000), 
('2023-03-06', 2190793000000), 
('2023-03-07', 2170195000000), 
('2023-03-08', 2193237000000), 
('2023-03-09', 2229623000000), 
('2023-03-10', 2188375000000), 
('2023-03-13', 2126677000000), 
('2023-03-14', 2042579000000), 
('2023-03-15', 2055823000000), 
('2023-03-16', 2066319000000), 
('2023-03-17', 2106166000000), 
('2023-03-20', 2098393000000), 
('2023-03-21', 2194631000000), 
('2023-03-22', 2279608000000), 
('2023-03-23', 2233956000000), 
('2023-03-24', 2218458000000), 
('2023-03-27', 2220131000000), 
('2023-03-28', 2231749000000), 
('2023-03-29', 2264862000000), 
('2023-03-30', 2271531000000), 
('2023-03-31', 2375171000000), 
('2023-04-03', 2221010000000), 
('2023-04-04', 2219375000000), 
('2023-04-05', 2243011000000), 
('2023-04-06', 2173663000000);

O código acima está em T-SQL para SQL Server. No entanto, estou aberto a qualquer solução de linguagem SQL que seja considerada 'SQL idiomática'.

Abordagem do PowerShell

Eu tenho uma abordagem que funciona para dados no PowerShell mostrados abaixo.

No entanto, estou imaginando como seria o SQL idiomático.

$wshosho_data = Invoke-RestMethod 'https://fred.stlouisfed.org/graph/fredgraph.csv?id=WSHOSHO' | ConvertFrom-Csv
$rrp_data     = Invoke-RestMethod ('https://markets.newyorkfed.org/api/rp/reverserepo/propositions/search.json?startDate={0}' -f '2022-04-08')
# ----------------------------------------------------------------------
$wshosho_sorted = $wshosho_data             | Sort-Object DATE
$rrp_sorted     = $rrp_data.repo.operations | Sort-Object operationDate
# ----------------------------------------------------------------------
$wshosho_sorted | Select-Object -Last 10 | ft *
$rrp_sorted     | Select-Object -Last 10 | ft operationDate, totalAmtAccepted
# ----------------------------------------------------------------------
$wshosho_dates = $wshosho_sorted | ForEach-Object DATE
$rrp_dates     = $rrp_sorted     | ForEach-Object operationDate
# ----------------------------------------------------------------------
$rrp_earliest     = $rrp_dates     | Sort-Object | Select-Object -First 1
$wshosho_earliest = $wshosho_dates | Sort-Object | Select-Object -First 1

$earliest = $rrp_earliest, $wshosho_earliest | Sort-Object | Select-Object -Last 1
# ----------------------------------------------------------------------
$dates = $rrp_dates + $wshosho_dates | Sort-Object | Select-Object -Unique | Where-Object { $_ -GE $earliest }
# ----------------------------------------------------------------------
$table = foreach ($date in $dates)
{
    $rrp_record     = $rrp_sorted.Where(     { $_.operationDate -le $date }, 'Last' )[0]
    $wshosho_record = $wshosho_sorted.Where( { $_.DATE          -le $date }, 'Last' )[0]

    $rrp_item     = [decimal] $rrp_record.totalAmtAccepted
    $wshosho_item = [decimal] $wshosho_record.WSHOSHO

    [PSCustomObject]@{
        date    = $date
        wshosho = $wshosho_item
        rrp     = $rrp_item
    }
}

A abordagem da Coruja Branca

Aqui está uma abordagem baseada na resposta de White Owl abaixo.

SELECT
RRP.DATE,
(
    CASE WHEN WSHOSHO.DATE IS NULL
        THEN
        (
            SELECT TOP(1) TBL.WSHOSHO FROM WSHOSHO as TBL WHERE TBL.DATE < RRP.DATE ORDER BY TBL.DATE DESC
        )
        ELSE
            WSHOSHO.WSHOSHO
        END
) AS WSHOSHO,
RRP.RRP
FROM RRP LEFT JOIN WSHOSHO ON (WSHOSHO.DATE = RRP.DATE);

Existem 2 tabelas principais: driverse driver_ridersque são conectadas por uma chave estrangeira. Todos os dias, alguns dos motoristas fazem uma ou várias viagens.

Há também uma mesadriver_rewards

driver_rewards
---
  ride_id
  reward_percent
  reward_amount

Um trabalho cron faria a varredura ridesa cada duas horas, selecionaria status = successpasseios e inseriria um registro de recompensa em driver_rewards. Mas apenas os passeios que ainda não foram inseridos - não houve nenhum registro ride_id = ?até driver_rewardsagora.

Como criar corretamente a consulta SQL que selecionaria tal rides? Eu estou ciente LEFT JOINe NOT EXISTSmas como eu os usaria aqui?

Se meu entendimento estiver correto, uma semijunção é uma maneira de selecionar registros de um conjunto de dados que possuem registros relacionados (por meio de um atributo comum) em outro conjunto. Então, de onde vem o "semi"?

Ok, eu sei, que o BORLAND BDE-32Bit é um pouco Retro, mas eu gostaria de usá-lo, pois não gostaria de instalar uma Solução de Servidor completa no meu pequeno PC Desktop.

OK. Começando com esta mensagem de erro:

INSERT INTO "E:\table.dbf" (NAME,SIZE,WEIGHT,AREA,BMP) VALUES ("foo","42","21,"007","");

A mensagem de erro após a instrução ExecSQL é:
Uso inválido de palavra-chave.
Token: TAMANHO, PESO, ÁREA, BMP) Número da linha: 1.

Não consigo encontrar nenhum erro ou o comando INSERT INTO não é suportado no LocalSQL?