1887 lines
40 KiB
Go
1887 lines
40 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.25.0
|
|
// source: feeds.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const countFeeds = `-- name: CountFeeds :one
|
|
SELECT
|
|
COUNT(*)
|
|
FROM
|
|
feeds
|
|
`
|
|
|
|
func (q *Queries) CountFeeds(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countFeeds)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countItems = `-- name: CountItems :one
|
|
SELECT
|
|
COUNT(*)
|
|
FROM
|
|
items
|
|
`
|
|
|
|
func (q *Queries) CountItems(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countItems)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const createFeed = `-- name: CreateFeed :one
|
|
INSERT INTO
|
|
feeds (
|
|
"url",
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
title,
|
|
"description",
|
|
link,
|
|
feed_link,
|
|
links,
|
|
updated,
|
|
updated_parsed,
|
|
published,
|
|
published_parsed,
|
|
"language",
|
|
copyright,
|
|
generator,
|
|
categories,
|
|
custom,
|
|
feed_type,
|
|
feed_version
|
|
)
|
|
VALUES
|
|
(
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6,
|
|
$7,
|
|
$8,
|
|
$9,
|
|
$10,
|
|
$11,
|
|
$12,
|
|
$13,
|
|
$14,
|
|
$15,
|
|
$16,
|
|
$17,
|
|
$18,
|
|
$19,
|
|
$20
|
|
)
|
|
RETURNING
|
|
id, url, created_at, updated_at, deleted_at, title, description, link, feed_link, links, updated, updated_parsed, published, published_parsed, language, copyright, generator, categories, custom, feed_type, feed_version
|
|
`
|
|
|
|
type CreateFeedParams struct {
|
|
Url string `json:"url"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Title pgtype.Text `json:"title"`
|
|
Description pgtype.Text `json:"description"`
|
|
Link pgtype.Text `json:"link"`
|
|
FeedLink pgtype.Text `json:"feed_link"`
|
|
Links []string `json:"links"`
|
|
Updated pgtype.Text `json:"updated"`
|
|
UpdatedParsed pgtype.Timestamptz `json:"updated_parsed"`
|
|
Published pgtype.Text `json:"published"`
|
|
PublishedParsed pgtype.Timestamptz `json:"published_parsed"`
|
|
Language pgtype.Text `json:"language"`
|
|
Copyright pgtype.Text `json:"copyright"`
|
|
Generator pgtype.Text `json:"generator"`
|
|
Categories []string `json:"categories"`
|
|
Custom []byte `json:"custom"`
|
|
FeedType pgtype.Text `json:"feed_type"`
|
|
FeedVersion pgtype.Text `json:"feed_version"`
|
|
}
|
|
|
|
func (q *Queries) CreateFeed(ctx context.Context, arg CreateFeedParams) (Feed, error) {
|
|
row := q.db.QueryRow(ctx, createFeed,
|
|
arg.Url,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Title,
|
|
arg.Description,
|
|
arg.Link,
|
|
arg.FeedLink,
|
|
arg.Links,
|
|
arg.Updated,
|
|
arg.UpdatedParsed,
|
|
arg.Published,
|
|
arg.PublishedParsed,
|
|
arg.Language,
|
|
arg.Copyright,
|
|
arg.Generator,
|
|
arg.Categories,
|
|
arg.Custom,
|
|
arg.FeedType,
|
|
arg.FeedVersion,
|
|
)
|
|
var i Feed
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Url,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Description,
|
|
&i.Link,
|
|
&i.FeedLink,
|
|
&i.Links,
|
|
&i.Updated,
|
|
&i.UpdatedParsed,
|
|
&i.Published,
|
|
&i.PublishedParsed,
|
|
&i.Language,
|
|
&i.Copyright,
|
|
&i.Generator,
|
|
&i.Categories,
|
|
&i.Custom,
|
|
&i.FeedType,
|
|
&i.FeedVersion,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createFeedAuthor = `-- name: CreateFeedAuthor :one
|
|
INSERT INTO
|
|
feed_authors (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
"name",
|
|
email,
|
|
feed_id
|
|
)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, name, email, feed_id
|
|
`
|
|
|
|
type CreateFeedAuthorParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Name pgtype.Text `json:"name"`
|
|
Email pgtype.Text `json:"email"`
|
|
FeedID int64 `json:"feed_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateFeedAuthor(ctx context.Context, arg CreateFeedAuthorParams) (FeedAuthor, error) {
|
|
row := q.db.QueryRow(ctx, createFeedAuthor,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Name,
|
|
arg.Email,
|
|
arg.FeedID,
|
|
)
|
|
var i FeedAuthor
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Name,
|
|
&i.Email,
|
|
&i.FeedID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createFeedDublinCore = `-- name: CreateFeedDublinCore :one
|
|
INSERT INTO
|
|
feed_dublin_cores (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
title,
|
|
creator,
|
|
author,
|
|
"subject",
|
|
"description",
|
|
publisher,
|
|
contributor,
|
|
"date",
|
|
"type",
|
|
format,
|
|
identifier,
|
|
source,
|
|
"language",
|
|
relation,
|
|
coverage,
|
|
rights,
|
|
feed_id
|
|
)
|
|
VALUES
|
|
(
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6,
|
|
$7,
|
|
$8,
|
|
$9,
|
|
$10,
|
|
$11,
|
|
$12,
|
|
$13,
|
|
$14,
|
|
$15,
|
|
$16,
|
|
$17,
|
|
$18,
|
|
$19,
|
|
$20
|
|
)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, title, creator, author, subject, description, publisher, contributor, date, type, format, identifier, source, language, relation, coverage, rights, feed_id
|
|
`
|
|
|
|
type CreateFeedDublinCoreParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Title []string `json:"title"`
|
|
Creator []string `json:"creator"`
|
|
Author []string `json:"author"`
|
|
Subject []string `json:"subject"`
|
|
Description []string `json:"description"`
|
|
Publisher []string `json:"publisher"`
|
|
Contributor []string `json:"contributor"`
|
|
Date []string `json:"date"`
|
|
Type []string `json:"type"`
|
|
Format []string `json:"format"`
|
|
Identifier []string `json:"identifier"`
|
|
Source []string `json:"source"`
|
|
Language []string `json:"language"`
|
|
Relation []string `json:"relation"`
|
|
Coverage []string `json:"coverage"`
|
|
Rights []string `json:"rights"`
|
|
FeedID int64 `json:"feed_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateFeedDublinCore(ctx context.Context, arg CreateFeedDublinCoreParams) (FeedDublinCore, error) {
|
|
row := q.db.QueryRow(ctx, createFeedDublinCore,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Title,
|
|
arg.Creator,
|
|
arg.Author,
|
|
arg.Subject,
|
|
arg.Description,
|
|
arg.Publisher,
|
|
arg.Contributor,
|
|
arg.Date,
|
|
arg.Type,
|
|
arg.Format,
|
|
arg.Identifier,
|
|
arg.Source,
|
|
arg.Language,
|
|
arg.Relation,
|
|
arg.Coverage,
|
|
arg.Rights,
|
|
arg.FeedID,
|
|
)
|
|
var i FeedDublinCore
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Creator,
|
|
&i.Author,
|
|
&i.Subject,
|
|
&i.Description,
|
|
&i.Publisher,
|
|
&i.Contributor,
|
|
&i.Date,
|
|
&i.Type,
|
|
&i.Format,
|
|
&i.Identifier,
|
|
&i.Source,
|
|
&i.Language,
|
|
&i.Relation,
|
|
&i.Coverage,
|
|
&i.Rights,
|
|
&i.FeedID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createFeedExtension = `-- name: CreateFeedExtension :one
|
|
INSERT INTO
|
|
feed_extensions (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
"name",
|
|
"value",
|
|
attrs,
|
|
children,
|
|
feed_id
|
|
)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6, $7, $8)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, name, value, attrs, children, feed_id
|
|
`
|
|
|
|
type CreateFeedExtensionParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Name pgtype.Text `json:"name"`
|
|
Value pgtype.Text `json:"value"`
|
|
Attrs []byte `json:"attrs"`
|
|
Children []byte `json:"children"`
|
|
FeedID int64 `json:"feed_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateFeedExtension(ctx context.Context, arg CreateFeedExtensionParams) (FeedExtension, error) {
|
|
row := q.db.QueryRow(ctx, createFeedExtension,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Name,
|
|
arg.Value,
|
|
arg.Attrs,
|
|
arg.Children,
|
|
arg.FeedID,
|
|
)
|
|
var i FeedExtension
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Name,
|
|
&i.Value,
|
|
&i.Attrs,
|
|
&i.Children,
|
|
&i.FeedID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createFeedImage = `-- name: CreateFeedImage :one
|
|
INSERT INTO
|
|
feed_images (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
"url",
|
|
title,
|
|
feed_id
|
|
)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, url, title, feed_id
|
|
`
|
|
|
|
type CreateFeedImageParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Url pgtype.Text `json:"url"`
|
|
Title pgtype.Text `json:"title"`
|
|
FeedID int64 `json:"feed_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateFeedImage(ctx context.Context, arg CreateFeedImageParams) (FeedImage, error) {
|
|
row := q.db.QueryRow(ctx, createFeedImage,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Url,
|
|
arg.Title,
|
|
arg.FeedID,
|
|
)
|
|
var i FeedImage
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Url,
|
|
&i.Title,
|
|
&i.FeedID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createFeedItunes = `-- name: CreateFeedItunes :one
|
|
INSERT INTO
|
|
feed_itunes (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
author,
|
|
"block",
|
|
"explicit",
|
|
keywords,
|
|
subtitle,
|
|
summary,
|
|
"image",
|
|
complete,
|
|
new_feed_url,
|
|
"type",
|
|
feed_id
|
|
)
|
|
VALUES
|
|
(
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6,
|
|
$7,
|
|
$8,
|
|
$9,
|
|
$10,
|
|
$11,
|
|
$12,
|
|
$13,
|
|
$14
|
|
)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, author, block, explicit, keywords, subtitle, summary, image, complete, new_feed_url, type, feed_id
|
|
`
|
|
|
|
type CreateFeedItunesParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Author pgtype.Text `json:"author"`
|
|
Block pgtype.Text `json:"block"`
|
|
Explicit pgtype.Text `json:"explicit"`
|
|
Keywords pgtype.Text `json:"keywords"`
|
|
Subtitle pgtype.Text `json:"subtitle"`
|
|
Summary pgtype.Text `json:"summary"`
|
|
Image pgtype.Text `json:"image"`
|
|
Complete pgtype.Text `json:"complete"`
|
|
NewFeedUrl pgtype.Text `json:"new_feed_url"`
|
|
Type pgtype.Text `json:"type"`
|
|
FeedID int64 `json:"feed_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateFeedItunes(ctx context.Context, arg CreateFeedItunesParams) (FeedItune, error) {
|
|
row := q.db.QueryRow(ctx, createFeedItunes,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Author,
|
|
arg.Block,
|
|
arg.Explicit,
|
|
arg.Keywords,
|
|
arg.Subtitle,
|
|
arg.Summary,
|
|
arg.Image,
|
|
arg.Complete,
|
|
arg.NewFeedUrl,
|
|
arg.Type,
|
|
arg.FeedID,
|
|
)
|
|
var i FeedItune
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Author,
|
|
&i.Block,
|
|
&i.Explicit,
|
|
&i.Keywords,
|
|
&i.Subtitle,
|
|
&i.Summary,
|
|
&i.Image,
|
|
&i.Complete,
|
|
&i.NewFeedUrl,
|
|
&i.Type,
|
|
&i.FeedID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createFeedItunesCategory = `-- name: CreateFeedItunesCategory :one
|
|
INSERT INTO
|
|
feed_itunes_categories (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
"text",
|
|
subcategory,
|
|
itunes_id
|
|
)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, text, subcategory, itunes_id
|
|
`
|
|
|
|
type CreateFeedItunesCategoryParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Text pgtype.Text `json:"text"`
|
|
Subcategory pgtype.Int8 `json:"subcategory"`
|
|
ItunesID int64 `json:"itunes_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateFeedItunesCategory(ctx context.Context, arg CreateFeedItunesCategoryParams) (FeedItunesCategory, error) {
|
|
row := q.db.QueryRow(ctx, createFeedItunesCategory,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Text,
|
|
arg.Subcategory,
|
|
arg.ItunesID,
|
|
)
|
|
var i FeedItunesCategory
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Text,
|
|
&i.Subcategory,
|
|
&i.ItunesID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createFeedItunesOwner = `-- name: CreateFeedItunesOwner :one
|
|
INSERT INTO
|
|
feed_itunes_owners (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
email,
|
|
"name",
|
|
itunes_id
|
|
)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, email, name, itunes_id
|
|
`
|
|
|
|
type CreateFeedItunesOwnerParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Email pgtype.Text `json:"email"`
|
|
Name pgtype.Text `json:"name"`
|
|
ItunesID int64 `json:"itunes_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateFeedItunesOwner(ctx context.Context, arg CreateFeedItunesOwnerParams) (FeedItunesOwner, error) {
|
|
row := q.db.QueryRow(ctx, createFeedItunesOwner,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Email,
|
|
arg.Name,
|
|
arg.ItunesID,
|
|
)
|
|
var i FeedItunesOwner
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Email,
|
|
&i.Name,
|
|
&i.ItunesID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createItem = `-- name: CreateItem :one
|
|
INSERT INTO
|
|
items (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
title,
|
|
"description",
|
|
content,
|
|
link,
|
|
links,
|
|
updated,
|
|
updated_parsed,
|
|
published,
|
|
published_parsed,
|
|
"guid",
|
|
categories,
|
|
custom,
|
|
feed_id
|
|
)
|
|
VALUES
|
|
(
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6,
|
|
$7,
|
|
$8,
|
|
$9,
|
|
$10,
|
|
$11,
|
|
$12,
|
|
$13,
|
|
$14,
|
|
$15,
|
|
$16
|
|
)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, title, description, content, link, links, updated, updated_parsed, published, published_parsed, guid, categories, custom, feed_id
|
|
`
|
|
|
|
type CreateItemParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Title pgtype.Text `json:"title"`
|
|
Description pgtype.Text `json:"description"`
|
|
Content pgtype.Text `json:"content"`
|
|
Link pgtype.Text `json:"link"`
|
|
Links []string `json:"links"`
|
|
Updated pgtype.Text `json:"updated"`
|
|
UpdatedParsed pgtype.Timestamptz `json:"updated_parsed"`
|
|
Published pgtype.Text `json:"published"`
|
|
PublishedParsed pgtype.Timestamptz `json:"published_parsed"`
|
|
Guid pgtype.Text `json:"guid"`
|
|
Categories []string `json:"categories"`
|
|
Custom []byte `json:"custom"`
|
|
FeedID int64 `json:"feed_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateItem(ctx context.Context, arg CreateItemParams) (Item, error) {
|
|
row := q.db.QueryRow(ctx, createItem,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Title,
|
|
arg.Description,
|
|
arg.Content,
|
|
arg.Link,
|
|
arg.Links,
|
|
arg.Updated,
|
|
arg.UpdatedParsed,
|
|
arg.Published,
|
|
arg.PublishedParsed,
|
|
arg.Guid,
|
|
arg.Categories,
|
|
arg.Custom,
|
|
arg.FeedID,
|
|
)
|
|
var i Item
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Description,
|
|
&i.Content,
|
|
&i.Link,
|
|
&i.Links,
|
|
&i.Updated,
|
|
&i.UpdatedParsed,
|
|
&i.Published,
|
|
&i.PublishedParsed,
|
|
&i.Guid,
|
|
&i.Categories,
|
|
&i.Custom,
|
|
&i.FeedID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createItemAuthor = `-- name: CreateItemAuthor :one
|
|
INSERT INTO
|
|
item_authors (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
"name",
|
|
email,
|
|
item_id
|
|
)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, name, email, item_id
|
|
`
|
|
|
|
type CreateItemAuthorParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Name pgtype.Text `json:"name"`
|
|
Email pgtype.Text `json:"email"`
|
|
ItemID int64 `json:"item_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateItemAuthor(ctx context.Context, arg CreateItemAuthorParams) (ItemAuthor, error) {
|
|
row := q.db.QueryRow(ctx, createItemAuthor,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Name,
|
|
arg.Email,
|
|
arg.ItemID,
|
|
)
|
|
var i ItemAuthor
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Name,
|
|
&i.Email,
|
|
&i.ItemID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createItemDublinCore = `-- name: CreateItemDublinCore :one
|
|
INSERT INTO
|
|
item_dublin_cores (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
title,
|
|
creator,
|
|
author,
|
|
"subject",
|
|
"description",
|
|
publisher,
|
|
contributor,
|
|
"date",
|
|
"type",
|
|
format,
|
|
identifier,
|
|
source,
|
|
"language",
|
|
relation,
|
|
coverage,
|
|
rights,
|
|
item_id
|
|
)
|
|
VALUES
|
|
(
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6,
|
|
$7,
|
|
$8,
|
|
$9,
|
|
$10,
|
|
$11,
|
|
$12,
|
|
$13,
|
|
$14,
|
|
$15,
|
|
$16,
|
|
$17,
|
|
$18,
|
|
$19,
|
|
$20
|
|
)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, title, creator, author, subject, description, publisher, contributor, date, type, format, identifier, source, language, relation, coverage, rights, item_id
|
|
`
|
|
|
|
type CreateItemDublinCoreParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Title []string `json:"title"`
|
|
Creator []string `json:"creator"`
|
|
Author []string `json:"author"`
|
|
Subject []string `json:"subject"`
|
|
Description []string `json:"description"`
|
|
Publisher []string `json:"publisher"`
|
|
Contributor []string `json:"contributor"`
|
|
Date []string `json:"date"`
|
|
Type []string `json:"type"`
|
|
Format []string `json:"format"`
|
|
Identifier []string `json:"identifier"`
|
|
Source []string `json:"source"`
|
|
Language []string `json:"language"`
|
|
Relation []string `json:"relation"`
|
|
Coverage []string `json:"coverage"`
|
|
Rights []string `json:"rights"`
|
|
ItemID int64 `json:"item_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateItemDublinCore(ctx context.Context, arg CreateItemDublinCoreParams) (ItemDublinCore, error) {
|
|
row := q.db.QueryRow(ctx, createItemDublinCore,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Title,
|
|
arg.Creator,
|
|
arg.Author,
|
|
arg.Subject,
|
|
arg.Description,
|
|
arg.Publisher,
|
|
arg.Contributor,
|
|
arg.Date,
|
|
arg.Type,
|
|
arg.Format,
|
|
arg.Identifier,
|
|
arg.Source,
|
|
arg.Language,
|
|
arg.Relation,
|
|
arg.Coverage,
|
|
arg.Rights,
|
|
arg.ItemID,
|
|
)
|
|
var i ItemDublinCore
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Creator,
|
|
&i.Author,
|
|
&i.Subject,
|
|
&i.Description,
|
|
&i.Publisher,
|
|
&i.Contributor,
|
|
&i.Date,
|
|
&i.Type,
|
|
&i.Format,
|
|
&i.Identifier,
|
|
&i.Source,
|
|
&i.Language,
|
|
&i.Relation,
|
|
&i.Coverage,
|
|
&i.Rights,
|
|
&i.ItemID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createItemExtension = `-- name: CreateItemExtension :one
|
|
INSERT INTO
|
|
item_extensions (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
"name",
|
|
"value",
|
|
attrs,
|
|
children,
|
|
item_id
|
|
)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6, $7, $8)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, name, value, attrs, children, item_id
|
|
`
|
|
|
|
type CreateItemExtensionParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Name pgtype.Text `json:"name"`
|
|
Value pgtype.Text `json:"value"`
|
|
Attrs []byte `json:"attrs"`
|
|
Children []byte `json:"children"`
|
|
ItemID int64 `json:"item_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateItemExtension(ctx context.Context, arg CreateItemExtensionParams) (ItemExtension, error) {
|
|
row := q.db.QueryRow(ctx, createItemExtension,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Name,
|
|
arg.Value,
|
|
arg.Attrs,
|
|
arg.Children,
|
|
arg.ItemID,
|
|
)
|
|
var i ItemExtension
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Name,
|
|
&i.Value,
|
|
&i.Attrs,
|
|
&i.Children,
|
|
&i.ItemID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createItemImage = `-- name: CreateItemImage :one
|
|
INSERT INTO
|
|
item_images (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
"url",
|
|
title,
|
|
item_id
|
|
)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, url, title, item_id
|
|
`
|
|
|
|
type CreateItemImageParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Url pgtype.Text `json:"url"`
|
|
Title pgtype.Text `json:"title"`
|
|
ItemID int64 `json:"item_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateItemImage(ctx context.Context, arg CreateItemImageParams) (ItemImage, error) {
|
|
row := q.db.QueryRow(ctx, createItemImage,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Url,
|
|
arg.Title,
|
|
arg.ItemID,
|
|
)
|
|
var i ItemImage
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Url,
|
|
&i.Title,
|
|
&i.ItemID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createItemItunes = `-- name: CreateItemItunes :one
|
|
INSERT INTO
|
|
item_itunes (
|
|
created_at,
|
|
updated_at,
|
|
deleted_at,
|
|
author,
|
|
"block",
|
|
"explicit",
|
|
keywords,
|
|
subtitle,
|
|
summary,
|
|
"image",
|
|
is_closed_captioned,
|
|
episode,
|
|
season,
|
|
"order",
|
|
episode_type,
|
|
item_id
|
|
)
|
|
VALUES
|
|
(
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6,
|
|
$7,
|
|
$8,
|
|
$9,
|
|
$10,
|
|
$11,
|
|
$12,
|
|
$13,
|
|
$14,
|
|
$15,
|
|
$16
|
|
)
|
|
RETURNING
|
|
id, created_at, updated_at, deleted_at, author, block, duration, explicit, keywords, subtitle, summary, image, is_closed_captioned, episode, season, "order", episode_type, item_id
|
|
`
|
|
|
|
type CreateItemItunesParams struct {
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Author pgtype.Text `json:"author"`
|
|
Block pgtype.Text `json:"block"`
|
|
Explicit pgtype.Text `json:"explicit"`
|
|
Keywords pgtype.Text `json:"keywords"`
|
|
Subtitle pgtype.Text `json:"subtitle"`
|
|
Summary pgtype.Text `json:"summary"`
|
|
Image pgtype.Text `json:"image"`
|
|
IsClosedCaptioned pgtype.Text `json:"is_closed_captioned"`
|
|
Episode pgtype.Text `json:"episode"`
|
|
Season pgtype.Text `json:"season"`
|
|
Order pgtype.Text `json:"order"`
|
|
EpisodeType pgtype.Text `json:"episode_type"`
|
|
ItemID int64 `json:"item_id"`
|
|
}
|
|
|
|
func (q *Queries) CreateItemItunes(ctx context.Context, arg CreateItemItunesParams) (ItemItune, error) {
|
|
row := q.db.QueryRow(ctx, createItemItunes,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.DeletedAt,
|
|
arg.Author,
|
|
arg.Block,
|
|
arg.Explicit,
|
|
arg.Keywords,
|
|
arg.Subtitle,
|
|
arg.Summary,
|
|
arg.Image,
|
|
arg.IsClosedCaptioned,
|
|
arg.Episode,
|
|
arg.Season,
|
|
arg.Order,
|
|
arg.EpisodeType,
|
|
arg.ItemID,
|
|
)
|
|
var i ItemItune
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Author,
|
|
&i.Block,
|
|
&i.Duration,
|
|
&i.Explicit,
|
|
&i.Keywords,
|
|
&i.Subtitle,
|
|
&i.Summary,
|
|
&i.Image,
|
|
&i.IsClosedCaptioned,
|
|
&i.Episode,
|
|
&i.Season,
|
|
&i.Order,
|
|
&i.EpisodeType,
|
|
&i.ItemID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getFeed = `-- name: GetFeed :one
|
|
SELECT
|
|
id, url, created_at, updated_at, deleted_at, title, description, link, feed_link, links, updated, updated_parsed, published, published_parsed, language, copyright, generator, categories, custom, feed_type, feed_version
|
|
FROM
|
|
feeds
|
|
WHERE
|
|
id = $1
|
|
`
|
|
|
|
func (q *Queries) GetFeed(ctx context.Context, id int64) (Feed, error) {
|
|
row := q.db.QueryRow(ctx, getFeed, id)
|
|
var i Feed
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Url,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Description,
|
|
&i.Link,
|
|
&i.FeedLink,
|
|
&i.Links,
|
|
&i.Updated,
|
|
&i.UpdatedParsed,
|
|
&i.Published,
|
|
&i.PublishedParsed,
|
|
&i.Language,
|
|
&i.Copyright,
|
|
&i.Generator,
|
|
&i.Categories,
|
|
&i.Custom,
|
|
&i.FeedType,
|
|
&i.FeedVersion,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getFeedAuthors = `-- name: GetFeedAuthors :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, name, email, feed_id
|
|
FROM
|
|
feed_authors
|
|
WHERE
|
|
feed_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetFeedAuthorsParams struct {
|
|
FeedID int64 `json:"feed_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetFeedAuthors(ctx context.Context, arg GetFeedAuthorsParams) ([]FeedAuthor, error) {
|
|
rows, err := q.db.Query(ctx, getFeedAuthors, arg.FeedID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []FeedAuthor{}
|
|
for rows.Next() {
|
|
var i FeedAuthor
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Name,
|
|
&i.Email,
|
|
&i.FeedID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getFeedDublinCores = `-- name: GetFeedDublinCores :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, title, creator, author, subject, description, publisher, contributor, date, type, format, identifier, source, language, relation, coverage, rights, feed_id
|
|
FROM
|
|
feed_dublin_cores
|
|
WHERE
|
|
feed_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetFeedDublinCoresParams struct {
|
|
FeedID int64 `json:"feed_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetFeedDublinCores(ctx context.Context, arg GetFeedDublinCoresParams) ([]FeedDublinCore, error) {
|
|
rows, err := q.db.Query(ctx, getFeedDublinCores, arg.FeedID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []FeedDublinCore{}
|
|
for rows.Next() {
|
|
var i FeedDublinCore
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Creator,
|
|
&i.Author,
|
|
&i.Subject,
|
|
&i.Description,
|
|
&i.Publisher,
|
|
&i.Contributor,
|
|
&i.Date,
|
|
&i.Type,
|
|
&i.Format,
|
|
&i.Identifier,
|
|
&i.Source,
|
|
&i.Language,
|
|
&i.Relation,
|
|
&i.Coverage,
|
|
&i.Rights,
|
|
&i.FeedID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getFeedExtensions = `-- name: GetFeedExtensions :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, name, value, attrs, children, feed_id
|
|
FROM
|
|
feed_extensions
|
|
WHERE
|
|
feed_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetFeedExtensionsParams struct {
|
|
FeedID int64 `json:"feed_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetFeedExtensions(ctx context.Context, arg GetFeedExtensionsParams) ([]FeedExtension, error) {
|
|
rows, err := q.db.Query(ctx, getFeedExtensions, arg.FeedID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []FeedExtension{}
|
|
for rows.Next() {
|
|
var i FeedExtension
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Name,
|
|
&i.Value,
|
|
&i.Attrs,
|
|
&i.Children,
|
|
&i.FeedID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getFeedImages = `-- name: GetFeedImages :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, url, title, feed_id
|
|
FROM
|
|
feed_images
|
|
WHERE
|
|
feed_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetFeedImagesParams struct {
|
|
FeedID int64 `json:"feed_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetFeedImages(ctx context.Context, arg GetFeedImagesParams) ([]FeedImage, error) {
|
|
rows, err := q.db.Query(ctx, getFeedImages, arg.FeedID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []FeedImage{}
|
|
for rows.Next() {
|
|
var i FeedImage
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Url,
|
|
&i.Title,
|
|
&i.FeedID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getFeedItunes = `-- name: GetFeedItunes :one
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, author, block, explicit, keywords, subtitle, summary, image, complete, new_feed_url, type, feed_id
|
|
FROM
|
|
feed_itunes
|
|
WHERE
|
|
feed_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetFeedItunes(ctx context.Context, feedID int64) (FeedItune, error) {
|
|
row := q.db.QueryRow(ctx, getFeedItunes, feedID)
|
|
var i FeedItune
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Author,
|
|
&i.Block,
|
|
&i.Explicit,
|
|
&i.Keywords,
|
|
&i.Subtitle,
|
|
&i.Summary,
|
|
&i.Image,
|
|
&i.Complete,
|
|
&i.NewFeedUrl,
|
|
&i.Type,
|
|
&i.FeedID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getFeedItunesCategories = `-- name: GetFeedItunesCategories :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, text, subcategory, itunes_id
|
|
FROM
|
|
feed_itunes_categories
|
|
WHERE
|
|
itunes_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetFeedItunesCategoriesParams struct {
|
|
ItunesID int64 `json:"itunes_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetFeedItunesCategories(ctx context.Context, arg GetFeedItunesCategoriesParams) ([]FeedItunesCategory, error) {
|
|
rows, err := q.db.Query(ctx, getFeedItunesCategories, arg.ItunesID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []FeedItunesCategory{}
|
|
for rows.Next() {
|
|
var i FeedItunesCategory
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Text,
|
|
&i.Subcategory,
|
|
&i.ItunesID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getFeedItunesOwners = `-- name: GetFeedItunesOwners :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, email, name, itunes_id
|
|
FROM
|
|
feed_itunes_owners
|
|
WHERE
|
|
itunes_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetFeedItunesOwnersParams struct {
|
|
ItunesID int64 `json:"itunes_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetFeedItunesOwners(ctx context.Context, arg GetFeedItunesOwnersParams) ([]FeedItunesOwner, error) {
|
|
rows, err := q.db.Query(ctx, getFeedItunesOwners, arg.ItunesID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []FeedItunesOwner{}
|
|
for rows.Next() {
|
|
var i FeedItunesOwner
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Email,
|
|
&i.Name,
|
|
&i.ItunesID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getFeeds = `-- name: GetFeeds :many
|
|
SELECT
|
|
id, url, created_at, updated_at, deleted_at, title, description, link, feed_link, links, updated, updated_parsed, published, published_parsed, language, copyright, generator, categories, custom, feed_type, feed_version
|
|
FROM
|
|
feeds
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$1
|
|
OFFSET
|
|
$2
|
|
`
|
|
|
|
type GetFeedsParams struct {
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetFeeds(ctx context.Context, arg GetFeedsParams) ([]Feed, error) {
|
|
rows, err := q.db.Query(ctx, getFeeds, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Feed{}
|
|
for rows.Next() {
|
|
var i Feed
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Url,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Description,
|
|
&i.Link,
|
|
&i.FeedLink,
|
|
&i.Links,
|
|
&i.Updated,
|
|
&i.UpdatedParsed,
|
|
&i.Published,
|
|
&i.PublishedParsed,
|
|
&i.Language,
|
|
&i.Copyright,
|
|
&i.Generator,
|
|
&i.Categories,
|
|
&i.Custom,
|
|
&i.FeedType,
|
|
&i.FeedVersion,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getItem = `-- name: GetItem :one
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, title, description, content, link, links, updated, updated_parsed, published, published_parsed, guid, categories, custom, feed_id
|
|
FROM
|
|
items
|
|
WHERE
|
|
id = $1
|
|
`
|
|
|
|
func (q *Queries) GetItem(ctx context.Context, id int64) (Item, error) {
|
|
row := q.db.QueryRow(ctx, getItem, id)
|
|
var i Item
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Description,
|
|
&i.Content,
|
|
&i.Link,
|
|
&i.Links,
|
|
&i.Updated,
|
|
&i.UpdatedParsed,
|
|
&i.Published,
|
|
&i.PublishedParsed,
|
|
&i.Guid,
|
|
&i.Categories,
|
|
&i.Custom,
|
|
&i.FeedID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getItemAuthors = `-- name: GetItemAuthors :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, name, email, item_id
|
|
FROM
|
|
item_authors
|
|
WHERE
|
|
item_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetItemAuthorsParams struct {
|
|
ItemID int64 `json:"item_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetItemAuthors(ctx context.Context, arg GetItemAuthorsParams) ([]ItemAuthor, error) {
|
|
rows, err := q.db.Query(ctx, getItemAuthors, arg.ItemID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ItemAuthor{}
|
|
for rows.Next() {
|
|
var i ItemAuthor
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Name,
|
|
&i.Email,
|
|
&i.ItemID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getItemDublinCores = `-- name: GetItemDublinCores :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, title, creator, author, subject, description, publisher, contributor, date, type, format, identifier, source, language, relation, coverage, rights, item_id
|
|
FROM
|
|
item_dublin_cores
|
|
WHERE
|
|
item_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetItemDublinCoresParams struct {
|
|
ItemID int64 `json:"item_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetItemDublinCores(ctx context.Context, arg GetItemDublinCoresParams) ([]ItemDublinCore, error) {
|
|
rows, err := q.db.Query(ctx, getItemDublinCores, arg.ItemID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ItemDublinCore{}
|
|
for rows.Next() {
|
|
var i ItemDublinCore
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Creator,
|
|
&i.Author,
|
|
&i.Subject,
|
|
&i.Description,
|
|
&i.Publisher,
|
|
&i.Contributor,
|
|
&i.Date,
|
|
&i.Type,
|
|
&i.Format,
|
|
&i.Identifier,
|
|
&i.Source,
|
|
&i.Language,
|
|
&i.Relation,
|
|
&i.Coverage,
|
|
&i.Rights,
|
|
&i.ItemID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getItemExtensions = `-- name: GetItemExtensions :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, name, value, attrs, children, item_id
|
|
FROM
|
|
item_extensions
|
|
WHERE
|
|
item_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetItemExtensionsParams struct {
|
|
ItemID int64 `json:"item_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetItemExtensions(ctx context.Context, arg GetItemExtensionsParams) ([]ItemExtension, error) {
|
|
rows, err := q.db.Query(ctx, getItemExtensions, arg.ItemID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ItemExtension{}
|
|
for rows.Next() {
|
|
var i ItemExtension
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Name,
|
|
&i.Value,
|
|
&i.Attrs,
|
|
&i.Children,
|
|
&i.ItemID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getItemImages = `-- name: GetItemImages :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, url, title, item_id
|
|
FROM
|
|
item_images
|
|
WHERE
|
|
item_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetItemImagesParams struct {
|
|
ItemID int64 `json:"item_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetItemImages(ctx context.Context, arg GetItemImagesParams) ([]ItemImage, error) {
|
|
rows, err := q.db.Query(ctx, getItemImages, arg.ItemID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ItemImage{}
|
|
for rows.Next() {
|
|
var i ItemImage
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Url,
|
|
&i.Title,
|
|
&i.ItemID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getItemItunes = `-- name: GetItemItunes :one
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, author, block, duration, explicit, keywords, subtitle, summary, image, is_closed_captioned, episode, season, "order", episode_type, item_id
|
|
FROM
|
|
item_itunes
|
|
WHERE
|
|
item_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetItemItunes(ctx context.Context, itemID int64) (ItemItune, error) {
|
|
row := q.db.QueryRow(ctx, getItemItunes, itemID)
|
|
var i ItemItune
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Author,
|
|
&i.Block,
|
|
&i.Duration,
|
|
&i.Explicit,
|
|
&i.Keywords,
|
|
&i.Subtitle,
|
|
&i.Summary,
|
|
&i.Image,
|
|
&i.IsClosedCaptioned,
|
|
&i.Episode,
|
|
&i.Season,
|
|
&i.Order,
|
|
&i.EpisodeType,
|
|
&i.ItemID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getItems = `-- name: GetItems :many
|
|
SELECT
|
|
id, created_at, updated_at, deleted_at, title, description, content, link, links, updated, updated_parsed, published, published_parsed, guid, categories, custom, feed_id
|
|
FROM
|
|
items
|
|
WHERE
|
|
feed_id = $1
|
|
ORDER BY
|
|
created_at DESC
|
|
LIMIT
|
|
$2
|
|
OFFSET
|
|
$3
|
|
`
|
|
|
|
type GetItemsParams struct {
|
|
FeedID int64 `json:"feed_id"`
|
|
Limit int32 `json:"limit"`
|
|
Offset int32 `json:"offset"`
|
|
}
|
|
|
|
func (q *Queries) GetItems(ctx context.Context, arg GetItemsParams) ([]Item, error) {
|
|
rows, err := q.db.Query(ctx, getItems, arg.FeedID, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Item{}
|
|
for rows.Next() {
|
|
var i Item
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.DeletedAt,
|
|
&i.Title,
|
|
&i.Description,
|
|
&i.Content,
|
|
&i.Link,
|
|
&i.Links,
|
|
&i.Updated,
|
|
&i.UpdatedParsed,
|
|
&i.Published,
|
|
&i.PublishedParsed,
|
|
&i.Guid,
|
|
&i.Categories,
|
|
&i.Custom,
|
|
&i.FeedID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|