sqlc-hs-0.4.0.0: templates/query.hs.jinja

{- This file was auto-generated from {{sourceFile}} by sqlc-hs. -}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
module {{moduleName}} where

{% if generatePostgresql %}
import {{ internalModuleName }} (Query(..), Enum, Params, Result)
import qualified Database.PostgreSQL.Simple
import qualified Database.PostgreSQL.Simple.FromRow
import qualified Database.PostgreSQL.Simple.ToField
import qualified Database.PostgreSQL.Simple.ToRow
{% endif %}
{% if generateHasql %}
import {{ internalModuleName }} (Query(..), Enum, Params)
{# The row type is named `Result`, and so is IsStatement's associated type. GHC
   rejects a qualified name on the left of an associated type instance
   (GHC-28329), so it is the row family that gets qualified instead. Kept as a
   template comment: it explains this template, not the code it emits. #}
import qualified {{ internalModuleName }}
import qualified Data.Int
import qualified Data.Vector
import qualified Hasql.Decoders
import qualified Hasql.Encoders
import qualified Hasql.Mapping.IsScalar
import qualified Hasql.Mapping.IsStatement
import qualified Hasql.Statement
{% endif %}
{% if generateSqlite %}
import {{ internalModuleName }} (Query(..), Enum, Params, Result)
import qualified Database.SQLite.Simple.FromRow
import qualified Database.SQLite.Simple.ToField
import qualified Database.SQLite.Simple.ToRow
{% endif %}
{% if generateMysql %}
import {{ internalModuleName }} (Query(..), Enum, Params, Result)
import qualified Database.MySQL.Simple.Param
import qualified Database.MySQL.Simple.QueryParams
import qualified Database.MySQL.Simple.QueryResults
import qualified Database.MySQL.Simple.Result
{% endif %}

{% for import in moduleImports  %}
import qualified {{ import.value }}
{% endfor %}

{{ haskellQueryName }} :: Query {{ escapedQueryName }} {{ escapedCommand }}
{{ haskellQueryName }} = Query {{ escapedSql }}

data instance Params {{ escapedQueryName }} = {{ haskellParamsName }}
  {
  {% for param in parameterColumns %}
    {{ param.value.name }} :: {{ param.value.type }}{% if !param.last %},{% endif %}
  {% endfor %}
  }

{% if generateHasql %}
data instance {{ internalModuleName }}.Result {{ escapedQueryName }} = {{ haskellResultName }}
{% else %}
data instance Result {{ escapedQueryName }} = {{ haskellResultName }}
{% endif %}
  {
  {% for column in resultColumns  %}
    {{ column.value.name }} :: !({{ column.value.type }}){% if !column.last %},{% endif %}
  {% endfor %}
  }

{% if generatePostgresql %}
instance Database.PostgreSQL.Simple.ToRow.ToRow (Params {{ escapedQueryName }}) where
  toRow {{ haskellParamsName }}{% if parameterColumns | empty %}{}{% else %}{..}{% endif%} =
    [ {% for param in queryColumns %}
      {% if param.value.slice %}
      {% if param.value.notNull %}
      Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList {{ param.value.name }})){% if !param.last %}, {% endif %}
      {% else %}
      Database.PostgreSQL.Simple.ToField.toField (fmap (Database.PostgreSQL.Simple.In . Data.Foldable.toList) {{ param.value.name }}){% if !param.last %}, {% endif %}
      {% endif %}
      {% else %}
      Database.PostgreSQL.Simple.ToField.toField {{ param.value.name }}{% if !param.last %}, {% endif %}
      {% endif %}
      {% endfor %}
    ]

instance Database.PostgreSQL.Simple.FromRow.FromRow (Result {{ escapedQueryName }}) where
  fromRow =
    pure {{ haskellResultName }}
    {% for column in resultColumns %}
      <*> Database.PostgreSQL.Simple.FromRow.field
    {% endfor %}
{% endif %}
{% if generateHasql %}
instance Hasql.Mapping.IsStatement.IsStatement (Params {{ escapedQueryName }}) where
  type Result (Params {{ escapedQueryName }}) = {{ hasqlResultType }}
  statement =
    Hasql.Statement.preparable sql paramsEncoder ({{ hasqlResultDecoder }})
    where
      Query sql = {{ haskellQueryName }}

      paramsEncoder :: Hasql.Encoders.Params (Params {{ escapedQueryName }})
      paramsEncoder =
        mconcat
          [ {% for param in encoderColumns %}
          Data.Functor.Contravariant.contramap (\{{ haskellParamsName }}{..} -> {{ param.value.name }}) (Hasql.Encoders.param ({{ param.value.encoder }})){% if !param.last %}, {% endif %}
          {% endfor %}
          ]
      {-# INLINE paramsEncoder #-}
{% if hasqlDecodesRows %}
      rowDecoder :: Hasql.Decoders.Row ({{ internalModuleName }}.Result {{ escapedQueryName }})
      rowDecoder =
        pure {{ haskellResultName }}
        {% for column in resultColumns %}
          <*> Hasql.Decoders.column ({{ column.value.decoder }})
        {% endfor %}
      {-# INLINE rowDecoder #-}
{% endif %}
{% endif %}

{% if generateSqlite %}
instance Database.SQLite.Simple.ToRow.ToRow (Params {{ escapedQueryName }}) where
  toRow {{ haskellParamsName }}{% if parameterColumns | empty %}{}{% else %}{..}{% endif%} =
    [ {% for param in queryColumns %}
      Database.SQLite.Simple.ToField.toField {{ param.value.name }}{% if !param.last %}, {% endif %}
      {% endfor %}
    ]

instance Database.SQLite.Simple.FromRow.FromRow (Result {{ escapedQueryName }}) where
  fromRow =
    pure {{ haskellResultName }}
    {% for column in resultColumns %}
      <*> Database.SQLite.Simple.FromRow.field
    {% endfor %}
{% endif %}

{% if generateMysql %}
instance Database.MySQL.Simple.QueryParams.QueryParams (Params {{ escapedQueryName }}) where
  renderParams {{ haskellParamsName }}{% if parameterColumns | empty %}{}{% else %}{..}{% endif%} =
    [ {% for param in queryColumns %}
      Database.MySQL.Simple.Param.render {{ param.value.name }}{% if !param.last %}, {% endif %}
      {% endfor %}
    ]

instance Database.MySQL.Simple.QueryResults.QueryResults (Result {{ escapedQueryName }}) where
  convertResults [{% for column in resultColumns %}a_{{ column.index }}{% if !column.last %}, {% endif %}{% endfor%}] [{% for column in resultColumns %}b_{{ column.index }}{% if !column.last %}, {% endif %}{% endfor%}] = {{ haskellResultName }}{% if resultColumns | empty %}{}{% else %}{..}{% endif%}
    {% if resultColumns %}
    where
      {% for column in resultColumns %}
      !{{ column.value.name }} = Database.MySQL.Simple.Result.convert a_{{ column.index }} b_{{ column.index }}
      {% endfor %}
    {% endif %}
  convertResults a b =
    Database.MySQL.Simple.QueryResults.convertError a b {{ resultColumns | length }}
{% endif %}