Safe Haskell	Safe-Inferred
Language	GHC2021

Napkin.Types.Core

Synopsis

data Name
- = Specific {
  - _unName :: SrcLitStr
  }
- | Star
textName :: Text -> Name
nameString :: Name -> String
nameText :: Name -> Text
nameLitStr :: Name -> SrcLitStr
nameStringQuoted :: Name -> Text
_name :: Iso' String Name
newtype Ref a = Ref {
- _unRef :: NonEmpty Name
}
text2Ref :: Text -> Ref a
newtype NormalizedTable = Normalized {
- _normalizedRef :: Ref Table
}
data ListedTableKind
- = Table
- | View
- | MaterializedView
- | External
data ListedTable = ListedTable {
- _tableKind :: ListedTableKind
- _normalized :: NormalizedTable
}
newtype TemporaryTableName = TemporaryTableName (Ref Table)
newtype SpecTableName = SpecTableName {
- baseTableName :: Ref Table
}
useSpecName :: SpecTableName -> Ref Table
class IsRef a where
- ref :: forall b. a -> Ref b
refComponentCount :: Ref a -> Int
stringRefIso :: Iso' String (Ref a)
refStringIso :: Iso' (Ref a) String
stringRef :: String -> Ref a
textRef :: Text -> Ref a
nameRef :: Name -> Ref a
namesRef :: [Name] -> Ref a
sNamesRef :: NonEmpty Name -> Ref a
sNameRef :: Name -> Ref a
refString :: Ref t -> String
specTableString :: SpecTableName -> String
refText :: Ref t -> Text
specTableText :: SpecTableName -> Text
retagRef :: Ref t -> Ref a
appendRef :: Ref a -> Name -> Ref a
star :: SExp
data Table
data Function
keywordRef :: String -> Ref Function
data Selected a = Selected {
- _selectRef :: Ref a
- _selectItem :: a
}
data Alias a = Alias {
- _aliasRef :: Maybe (Ref a)
- _aliasItem :: a
}
nonAlias :: a -> Alias a
class WithName a where
- as :: b -> Ref b -> a b
sa :: WithName a => Ref b -> b -> a b
selectToAlias :: Selected a -> Alias a
data StructField
- = StructFieldSharp Int
- | StructFieldNamed Text
data Value
- = VDouble !Double
- | VInt !Int64
- | VBool !Bool
- | VDate !Day
- | VDateTime !UTCTime
- | VText !SrcLitStr
- | VBinary !ByteString
- | VInterval !Interval
- | VNull
- | VDatePart !DatePart
newtype Interval = Interval {
- _unInterval :: [(SExp, DatePart)]
}
data IntInterval = IntInterval SExp DatePart
data ArrayBase
- = ArrayBase0
- | ArrayBase1
data Nullability
- = Nullable
- | NotNull
data Field = Field Nullability Type
data SExp
- = Lit Value
- | Var (Ref SExp)
- | ArraySelect Query
- | ArrayItem {
  - _sExp_ArrayItem_base :: ArrayBase
  - _sExp_ArrayItem_null :: Nullability
  - _sExp_ArrayItem_arr :: SExp
  - _sExp_ArrayItem_idx :: SExp
  }
- | Array {
  - _sExp_Array_itemType :: Maybe Type
  - _sExp_Array_items :: [SExp]
  }
- | Struct {
  - _sExp_Struct_types :: Maybe (OMap StructField Type)
  - _sExp_Struct_values :: OMap StructField SExp
  }
- | FieldAccess {
  - _sExp_fieldAccess_base :: SExp
  - _sExp_fieldAccess_name :: StructField
  }
- | Extern ExternFun
- | Case [(SExp, SExp)] SExp
- | ExceptColumns SExp [Ref SExp]
- | SubQuery Query
- | NativeExpr NativeExpr
data NativeExpr
- = PostgresAExpr AExpr
- | SimpleSQLParserScalarExpr ScalarExpr
var :: Ref a -> SExp
varString :: String -> SExp
nil :: SExp
data NullStrategy
- = IgnoreNulls
- | RespectNulls
data Distinctness
- = Distinct
- | NonDistinct
type Partition = [SExp]
data WOver = WOver {
- _overPartition :: Partition
- _overOrder :: Order
- _overFrame :: Maybe WindowFrame
}
data WindowFrameUnit
- = WindowRows
- | WindowRange
data WindowFun = SimpleWindow (Ref Function) [SExp] WOver (Maybe NullStrategy)
data WindowFrame
- = WindowBetween WindowFrameUnit FrameLength FrameLength
- | WindowFrom WindowFrameUnit FrameLength
data FrameLength
- = CurrentRow
- | Unbounded
- | LimitedPreceding SExp
- | LimitedFollowing SExp
data FunModifier
- = ModDistinct Distinctness
- | ModNulls NullStrategy
- | ModOrder Order
- | ModLimit Int
- | ModOver WOver
data ExternFun
- = SimpleExtern (Ref Function) [SExp]
- | ParensExtern [ParensOperator]
- | ModExtern (Ref Function) [SExp] [FunModifier]
- | Cast SExp Type
- | SafeCast SExp Type
- | ExternWindow WindowFun
- | ExternRaw String
type OriginTypeName = Text
data Type
- = TySmallInt
- | TyInteger
- | TyBigInt
- | TyDecimal
- | TyReal
- | TyDouble
- | TyBool
- | TyChar
- | TyVarChar
- | TyBlob
- | TyUnknown OriginTypeName
- | TyVarCharWithLen Int
- | TyDate
- | TyTimestamp
- | TyDatetime
- | TyInterval
- | TyLimited Type Int
- | Ty2DLimited Type Int Int
- | TyArray Type (Maybe Int)
- | TyStruct (OMap StructField Type)
data DatePart
- = Millennium
- | Century
- | Decade
- | Epoch
- | Year
- | Quarter
- | Month
- | Week
- | DayOfWeek
- | DayOfYear
- | Day
- | Hour
- | Minute
- | Second
- | Millisecond
- | Microsecond
type Order = [OrderPart]
type GroupBy = [SExp]
data OrderDir
- = Asc
- | Desc
invertOrder :: OrderDir -> OrderDir
data NullOrder
- = NullsFirst
- | NullsLast
data OrderPart = OrderPart {
- _opExp :: SExp
- _opOrder :: OrderDir
- _opNulls :: Maybe NullOrder
}
order :: SExp -> OrderPart
data Relation
- = TableRelation (Ref Table)
- | QueryRelation Query
- | ArrayRelation SExp
- | RawRelation [Ref Table] String
table :: Ref a -> Relation
data JoinType
- = JoinLeft
- | JoinRight
- | JoinInner
- | JoinCross
- | JoinOuter
data From = From (Selected Relation) [(Selected Relation, JoinType, Either (Maybe SExp) [Ref SExp])]
fromAliases :: From -> [Ref Relation]
data UnionType
- = SetUnion
- | DuplicateUnion
- | IntersectUnion
- | MinusUnion
data RawQuery = RawQuery {
- _rawQuery_deps :: [Ref Table]
- _rawQuery_raw :: String
}
data CteBody
- = JustCteBody (Selected Query)
- | PositionalBoundsCteBody (NonEmpty (Ref SExp)) (Selected Query)
data WithClauses = WithClauses {
- _withClauses_recursive :: Bool
- _withClauses_cteBodies :: OMap (Ref Query) CteBody
}
orderWithInserted :: WithClauses -> [(Ref Query, CteBody)]
cteRefs :: WithClauses -> Set (Ref a)
data AsStruct
- = AsStruct
- | AsStructNo
- | AsValue
type Keyword = Ref Function
data ParensOperatorArgument
- = ParensOperatorArgument [Keyword] (Alias SExp)
- | ParensOperatorConst [Keyword]
data ParensOperator
- = ParensOperator [Ref Function] [ParensOperatorArgument]
- | ParensLessOperator [Ref Function]
mapSExpOfParensOperatorArg :: (SExp -> SExp) -> ParensOperatorArgument -> ParensOperatorArgument
type ColumnComment = (Ref SExp, Text)
data Query
- = Query {
  - _queryWith :: WithClauses
  - _querySelect :: [Alias SExp]
  - _queryComments :: [ColumnComment]
  - _queryFrom :: Maybe From
  - _queryTableOperator :: Maybe ParensOperator
  - _queryWhere :: Maybe SExp
  - _queryHaving :: Maybe SExp
  - _queryGroup :: GroupBy
  - _queryOrder :: Order
  - _queryLimit :: Maybe Int
  - _queryOffset :: Maybe Int
  - _queryDistinct :: Distinctness
  - _queryAs :: AsStruct
  }
- | Union {
  - _unionType :: UnionType
  - _unionQuery1 :: Query
  - _unionQuery2 :: Query
  - _unionWiths :: WithClauses
  }
- | QueryRaw RawQuery
- | NativeQuery NativeQuery
data NativeQuery
- = PostgresSelectStmt SelectStmt
- | SimpleSQLParserQueryExpr QueryExpr
emptyQuery :: Query
mkUnion :: UnionType -> [Query] -> Query
collectUnionQueries :: Query -> NonEmpty Query
data DefinedRelation = forall s.(AsRelation s, HasDefinition s, MaybeQuery s) => DefinedRelation s
data DefinedQuery = forall s.HasDefinition s => DefinedQuery s
class AsRelation s where
- asRelation :: s -> Relation
class HasDefinition s where
- defQuery :: Lens s s Query Query
class MaybeQuery s where
- getQuery :: s -> Maybe Query
queryFullySpecified :: Data a => a -> Bool
opOrder :: Lens' OrderPart OrderDir
opNulls :: Lens' OrderPart (Maybe NullOrder)
opExp :: Lens' OrderPart SExp
rawQuery_raw :: Lens' RawQuery String
rawQuery_deps :: Lens' RawQuery [Ref Table]
unionWiths :: Traversal' Query WithClauses
unionType :: Traversal' Query UnionType
unionQuery2 :: Traversal' Query Query
unionQuery1 :: Traversal' Query Query
queryWith :: Traversal' Query WithClauses
queryWhere :: Traversal' Query (Maybe SExp)
queryTableOperator :: Traversal' Query (Maybe ParensOperator)
querySelect :: Traversal' Query [Alias SExp]
queryOrder :: Traversal' Query Order
queryOffset :: Traversal' Query (Maybe Int)
queryLimit :: Traversal' Query (Maybe Int)
queryHaving :: Traversal' Query (Maybe SExp)
queryGroup :: Traversal' Query GroupBy
queryFrom :: Traversal' Query (Maybe From)
queryDistinct :: Traversal' Query Distinctness
queryComments :: Traversal' Query [ColumnComment]
queryAs :: Traversal' Query AsStruct
_NativeQuery :: Prism' Query NativeQuery
_QueryRaw :: Prism' Query RawQuery
_Union :: Prism' Query (UnionType, Query, Query, WithClauses)
_Query :: Prism' Query (WithClauses, [Alias SExp], [ColumnComment], Maybe From, Maybe ParensOperator, Maybe SExp, Maybe SExp, GroupBy, Order, Maybe Int, Maybe Int, Distinctness, AsStruct)
_From :: Iso' From (Selected Relation, [(Selected Relation, JoinType, Either (Maybe SExp) [Ref SExp])])
_Star :: Prism' Name ()
_Specific :: Prism' Name SrcLitStr
_JoinOuter :: Prism' JoinType ()
_JoinCross :: Prism' JoinType ()
_JoinInner :: Prism' JoinType ()
_JoinRight :: Prism' JoinType ()
_JoinLeft :: Prism' JoinType ()
_RawRelation :: Prism' Relation ([Ref Table], String)
_ArrayRelation :: Prism' Relation SExp
_QueryRelation :: Prism' Relation Query
_TableRelation :: Prism' Relation (Ref Table)
unRef :: forall k (a :: k) k (a :: k). Iso (Ref (a :: k)) (Ref (a :: k)) (NonEmpty Name) (NonEmpty Name)
_VDatePart :: Prism' Value DatePart
_VNull :: Prism' Value ()
_VInterval :: Prism' Value Interval
_VBinary :: Prism' Value ByteString
_VText :: Prism' Value SrcLitStr
_VDateTime :: Prism' Value UTCTime
_VDate :: Prism' Value Day
_VBool :: Prism' Value Bool
_VInt :: Prism' Value Int64
_VDouble :: Prism' Value Double
_Microsecond :: Prism' DatePart ()
_Millisecond :: Prism' DatePart ()
_Second :: Prism' DatePart ()
_Minute :: Prism' DatePart ()
_Hour :: Prism' DatePart ()
_Day :: Prism' DatePart ()
_DayOfYear :: Prism' DatePart ()
_DayOfWeek :: Prism' DatePart ()
_Week :: Prism' DatePart ()
_Month :: Prism' DatePart ()
_Quarter :: Prism' DatePart ()
_Year :: Prism' DatePart ()
_Epoch :: Prism' DatePart ()
_Decade :: Prism' DatePart ()
_Century :: Prism' DatePart ()
_Millennium :: Prism' DatePart ()
_NativeExpr :: Prism' SExp NativeExpr
_SubQuery :: Prism' SExp Query
_ExceptColumns :: Prism' SExp (SExp, [Ref SExp])
_Case :: Prism' SExp ([(SExp, SExp)], SExp)
_Extern :: Prism' SExp ExternFun
_FieldAccess :: Prism' SExp (SExp, StructField)
_Struct :: Prism' SExp (Maybe (OMap StructField Type), OMap StructField SExp)
_Array :: Prism' SExp (Maybe Type, [SExp])
_ArrayItem :: Prism' SExp (ArrayBase, Nullability, SExp, SExp)
_ArraySelect :: Prism' SExp Query
_Var :: Prism' SExp (Ref SExp)
_Lit :: Prism' SExp Value
selectRef :: forall a. Lens' (Selected a) (Ref a)
selectItem :: forall a. Lens' (Selected a) a
aliasRef :: forall a. Lens' (Alias a) (Maybe (Ref a))
aliasItem :: forall a. Lens' (Alias a) a
overPartition :: Lens' WOver Partition
overOrder :: Lens' WOver Order
overFrame :: Lens' WOver (Maybe WindowFrame)
normalizedRef :: Iso' NormalizedTable (Ref Table)
tableKind :: Lens' ListedTable ListedTableKind
normalized :: Lens' ListedTable NormalizedTable
unName :: Traversal' Name SrcLitStr
withClauses_recursive :: Lens' WithClauses Bool
withClauses_cteBodies :: Lens' WithClauses (OMap (Ref Query) CteBody)
_WithClauses :: Iso' WithClauses (Bool, OMap (Ref Query) CteBody)
allQueryComments :: Lens' Query [ColumnComment]
refNamespace :: Lens' (Ref a) (Maybe Name)
class Val a where
- val :: Prism' Value a
convS :: Lens' Text String
integral :: (Integral a, Integral b) => Iso' a b
_lit :: Val a => Prism' SExp a
lit :: Val a => a -> SExp
interval :: [(Double, DatePart)] -> SExp
txt :: String -> SExp
fullWindow :: WOver
class TableRef a where
- tableRef :: Lens' a (Ref Table)
relationRef :: TableRef a => Getter a Relation
varAs :: Ref a -> Selected SExp
asSelf :: SExp -> Selected SExp
funAs :: (SExp -> b) -> Ref b -> Selected b
selectToRef :: Selected SExp -> SExp
selectedExps :: Traversal' [Selected a] a
selectedNames :: Traversal' [Selected a0] String
refName :: Traversal (Ref a) (Ref a1) String String
refLitName :: Traversal (Ref a) (Ref a1) SrcLitStr SrcLitStr
refRoot :: Lens' (Ref a) Name
refJustRoot :: Ref a -> Ref a
refParentRoot :: Ref a -> ([String], Maybe String)
ne :: Iso' [a] (NonEmpty a)
selectedName :: Traversal' (Selected a) Name
atAlias :: (Applicative f, Choice p) => Ref t -> Optic' p f (Alias t) (Alias t)
aliasedNames :: HasDefinition s => Traversal' s (Ref SExp)
viewAliasedNames :: (MaybeQuery s, Applicative f, Contravariant f) => (Ref SExp -> f (Ref SExp)) -> s -> f s
scopeRefs :: Data b => Ref t -> b -> b
scopeExps :: Data b => Ref t -> b -> b
modifyExterns :: Data b => (ExternFun -> SExp) -> b -> b
(^^.) :: Ref Relation -> Name -> SExp
data AggLevel
- = Unit
- | Agg
- | Analytic
data UpdateQuery = UpdateQuery {
- _updateQueryTarget :: Alias (Ref Table)
- _updateQuerySet :: OMap Name SExp
- _updateQueryFrom :: Maybe From
- _updateQueryWhere :: Maybe SExp
}
updateQueryWhere :: Lens' UpdateQuery (Maybe SExp)
updateQueryTarget :: Lens' UpdateQuery (Alias (Ref Table))
updateQuerySet :: Lens' UpdateQuery (OMap Name SExp)
updateQueryFrom :: Lens' UpdateQuery (Maybe From)
pattern NapkinTablePrefix :: (Eq a, IsString a) => a
pattern NapkinTableSeparator :: (Eq a, IsString a) => a
isTemporaryTable :: Ref Table -> Bool
tmpTableNameFormat :: UTCTime -> Text -> Text
getUTCTimeTemporaryTable :: Ref Table -> Maybe UTCTime
getTemporaryTableName :: MonadIO m => m (Ref b)

Documentation

data Name #

Copyright : (c) Soostone Inc, 2020 License : AllRightsReserved Stability : experimental Portability : POSIX

Constructors

Specific
Fields _unName :: SrcLitStr
Star

Instances

Instances details

FromJSON Name #
Instance details Defined in Napkin.Types.Core Methods parseJSON :: Value -> Parser Name # parseJSONList :: Value -> Parser [Name] #
ToJSON Name #
Instance details Defined in Napkin.Types.Core Methods toJSON :: Name -> Value # toEncoding :: Name -> Encoding # toJSONList :: [Name] -> Value # toEncodingList :: [Name] -> Encoding #
Data Name #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name # toConstr :: Name -> Constr # dataTypeOf :: Name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) # gmapT :: (forall b. Data b => b -> b) -> Name -> Name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #
IsString Name #
Instance details Defined in Napkin.Types.Core Methods fromString :: String -> Name #
Monoid Name #
Instance details Defined in Napkin.Types.Core Methods mempty :: Name # mappend :: Name -> Name -> Name # mconcat :: [Name] -> Name #
Semigroup Name #
Instance details Defined in Napkin.Types.Core Methods (<>) :: Name -> Name -> Name # sconcat :: NonEmpty Name -> Name # stimes :: Integral b => b -> Name -> Name #
Generic Name #
Instance details Defined in Napkin.Types.Core Associated Types type Rep Name :: Type -> Type # Methods from :: Name -> Rep Name x # to :: Rep Name x -> Name #
Show Name #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #
FromField Name #
Instance details Defined in Napkin.Parse.AEDA.CSVParser Methods parseField :: Field -> Parser Name #
ToField Name #
Instance details Defined in Napkin.Parse.AEDA.CSVParser Methods toField :: Name -> Field #
NFData Name #
Instance details Defined in Napkin.Types.Core Methods rnf :: Name -> () #
Eq Name #
Instance details Defined in Napkin.Types.Core Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Ord Name #
Instance details Defined in Napkin.Types.Core Methods compare :: Name -> Name -> Ordering # (<) :: Name -> Name -> Bool # (<=) :: Name -> Name -> Bool # (>) :: Name -> Name -> Bool # (>=) :: Name -> Name -> Bool # max :: Name -> Name -> Name # min :: Name -> Name -> Name #
Hashable Name #
Instance details Defined in Napkin.Types.Core Methods hashWithSalt :: Int -> Name -> Int # hash :: Name -> Int #
IsRef Name #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). Name -> Ref b #
FromField Name #
Instance details Defined in Napkin.Run.PGCommon Methods fromField :: FieldParser Name #
FromRow Name #
Instance details Defined in Napkin.Run.PGCommon Methods fromRow :: RowParser Name #
RenderSql Name BigQuery #
Instance details Defined in Napkin.Render.BigQuery Methods renderSql :: BigQuery -> Name -> Doc #
RenderSql Name MsSql #
Instance details Defined in Napkin.Render.MsSql Methods renderSql :: MsSql -> Name -> Doc #
RenderSql Name Postgres #
Instance details Defined in Napkin.Render.Postgres Methods renderSql :: Postgres -> Name -> Doc #
RenderSql Name Redshift #
Instance details Defined in Napkin.Render.Redshift Methods renderSql :: Redshift -> Name -> Doc #
RenderSql Name Sqlite #
Instance details Defined in Napkin.Render.Sqlite Methods renderSql :: Sqlite -> Name -> Doc #
Lift Name #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Name -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Name -> Code m Name #
Lift (NonEmpty Name) #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => NonEmpty Name -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => NonEmpty Name -> Code m (NonEmpty Name) #
Buildable [Name] #
Instance details Defined in Napkin.Types.Core Methods build :: [Name] -> Builder #
IsRef (NonEmpty Name) #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). NonEmpty Name -> Ref b #
IsRef [Name] #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). [Name] -> Ref b #
HasDeps (OMap Name SExp) #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: OMap Name SExp -> Set (Ref Table) # traverseDependencies :: Fold (OMap Name SExp) (Ref Table) #
Cons (Ref a) (Ref a) Name Name #
Instance details Defined in Napkin.Types.Core Methods _Cons :: Prism (Ref a) (Ref a) (Name, Ref a) (Name, Ref a) #
Snoc (Ref a) (Ref a) Name Name #
Instance details Defined in Napkin.Types.Core Methods _Snoc :: Prism (Ref a) (Ref a) (Ref a, Name) (Ref a, Name) #
type Rep Name #
Instance details Defined in Napkin.Types.Core type Rep Name = D1 ('MetaData "Name" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "Specific" 'PrefixI 'True) (S1 ('MetaSel ('Just "_unName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SrcLitStr)) :+: C1 ('MetaCons "Star" 'PrefixI 'False) (U1 :: Type -> Type))

textName :: Text -> Name #

nameString :: Name -> String #

nameText :: Name -> Text #

nameLitStr :: Name -> SrcLitStr #

nameStringQuoted :: Name -> Text #

_name :: Iso' String Name #

newtype Ref a #

A way to refer to entities like fields, tables, schemas, etc. Namespacing is common so we keep a list here.

Constructors

Ref
Fields _unRef :: NonEmpty Name

Instances

Instances details

(BeamMigrateSqlBackend bk, FromBackendRow bk Text) => FromBackendRow bk (Ref a) #
Instance details Defined in Napkin.Metadata.Instances Methods fromBackendRow :: FromBackendRowM bk (Ref a) # valuesNeeded :: Proxy bk -> Proxy (Ref a) -> Int #
HasSqlValueSyntax bk Text => HasSqlValueSyntax bk (Ref a) #
Instance details Defined in Napkin.Metadata.Instances Methods sqlValueSyntax :: Ref a -> bk #
BeamSqlBackend bk => HasSqlEqualityCheck bk (Ref a) #
Instance details Defined in Napkin.Metadata.Instances Methods sqlEqE :: Proxy (Ref a) -> Proxy bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk # sqlNeqE :: Proxy (Ref a) -> Proxy bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk # sqlEqTriE :: Proxy (Ref a) -> Proxy bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk # sqlNeqTriE :: Proxy (Ref a) -> Proxy bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk #
BeamMigrateSqlBackend bk => HasDefaultSqlDataType bk (Ref a) #
Instance details Defined in Napkin.Metadata.Instances Methods defaultSqlDataType :: Proxy (Ref a) -> Proxy bk -> Bool -> BeamSqlBackendDataTypeSyntax bk # defaultSqlDataTypeConstraints :: Proxy (Ref a) -> Proxy bk -> Bool -> [FieldCheck] #
BeamSqlBackend bk => DataTypeForBackend bk (Ref b) #
Instance details Defined in Napkin.Metadata.Migrations Methods dbType :: DataType bk (Ref b) #
Lift (Ref a :: Type) #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Ref a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Ref a -> Code m (Ref a) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) BigQuery #
Instance details Defined in Napkin.Run.BigQuery Methods execCommand :: MonadNapkin BigQuery m => BackendConn BigQuery -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) MsSql #
Instance details Defined in Napkin.Run.MsSql Methods execCommand :: MonadNapkin MsSql m => BackendConn MsSql -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) Postgres #
Instance details Defined in Napkin.Run.Postgres Methods execCommand :: MonadNapkin Postgres m => BackendConn Postgres -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) Redshift #
Instance details Defined in Napkin.Run.Redshift Methods execCommand :: MonadNapkin Redshift m => BackendConn Redshift -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) Sqlite #
Instance details Defined in Napkin.Run.Sqlite Methods execCommand :: MonadNapkin Sqlite m => BackendConn Sqlite -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
FromJSON (Ref a) #
Instance details Defined in Napkin.Types.Core Methods parseJSON :: Value -> Parser (Ref a) # parseJSONList :: Value -> Parser [Ref a] #
FromJSONKey (Ref a) #
Instance details Defined in Napkin.Types.Core Methods fromJSONKey :: FromJSONKeyFunction (Ref a) # fromJSONKeyList :: FromJSONKeyFunction [Ref a] #
ToJSON (Ref a) #
Instance details Defined in Napkin.Types.Core Methods toJSON :: Ref a -> Value # toEncoding :: Ref a -> Encoding # toJSONList :: [Ref a] -> Value # toEncodingList :: [Ref a] -> Encoding #
ToJSONKey (Ref a) #
Instance details Defined in Napkin.Types.Core Methods toJSONKey :: ToJSONKeyFunction (Ref a) # toJSONKeyList :: ToJSONKeyFunction [Ref a] #
(Typeable a, Typeable k) => Data (Ref a) #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ref a -> c (Ref a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ref a) # toConstr :: Ref a -> Constr # dataTypeOf :: Ref a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ref a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ref a)) # gmapT :: (forall b. Data b => b -> b) -> Ref a -> Ref a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ref a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ref a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ref a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ref a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ref a -> m (Ref a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ref a -> m (Ref a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ref a -> m (Ref a) #
IsString (Ref Function) #
Instance details Defined in Napkin.Types.Core Methods fromString :: String -> Ref Function #
IsString (Ref a) #
Instance details Defined in Napkin.Types.Core Methods fromString :: String -> Ref a #
Semigroup (Ref a) #
Instance details Defined in Napkin.Types.Core Methods (<>) :: Ref a -> Ref a -> Ref a # sconcat :: NonEmpty (Ref a) -> Ref a # stimes :: Integral b => b -> Ref a -> Ref a #
Generic (Ref a) #
Instance details Defined in Napkin.Types.Core Associated Types type Rep (Ref a) :: Type -> Type # Methods from :: Ref a -> Rep (Ref a) x # to :: Rep (Ref a) x -> Ref a #
Show (Ref a) #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Ref a -> ShowS # show :: Ref a -> String # showList :: [Ref a] -> ShowS #
FoldCase (Ref Function) #
Instance details Defined in Napkin.Types.Core Methods foldCase :: Ref Function -> Ref Function # foldCaseList :: [Ref Function] -> [Ref Function]
NFData (Ref a) #
Instance details Defined in Napkin.Types.Core Methods rnf :: Ref a -> () #
Buildable (Ref a) #
Instance details Defined in Napkin.Types.Core Methods build :: Ref a -> Builder #
Eq (Ref a) #
Instance details Defined in Napkin.Types.Core Methods (==) :: Ref a -> Ref a -> Bool # (/=) :: Ref a -> Ref a -> Bool #
Ord (Ref a) #
Instance details Defined in Napkin.Types.Core Methods compare :: Ref a -> Ref a -> Ordering # (<) :: Ref a -> Ref a -> Bool # (<=) :: Ref a -> Ref a -> Bool # (>) :: Ref a -> Ref a -> Bool # (>=) :: Ref a -> Ref a -> Bool # max :: Ref a -> Ref a -> Ref a # min :: Ref a -> Ref a -> Ref a #
Hashable (Ref a) #
Instance details Defined in Napkin.Types.Core Methods hashWithSalt :: Int -> Ref a -> Int # hash :: Ref a -> Int #
AsRelation (Ref a) #
Instance details Defined in Napkin.Types.Core Methods asRelation :: Ref a -> Relation #
IsRef (Ref a) #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). Ref a -> Ref b #
TableRef (Ref Table) #
Instance details Defined in Napkin.Types.Core Methods tableRef :: Lens' (Ref Table) (Ref Table) #
HasDeps (Ref Table) #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: Ref Table -> Set (Ref Table) # traverseDependencies :: Fold (Ref Table) (Ref Table) #
TableRenamer (Ref Table) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Ref Table -> Ref Table #
RenderSql (Ref t) BigQuery #
Instance details Defined in Napkin.Render.BigQuery Methods renderSql :: BigQuery -> Ref t -> Doc #
RenderSql (Ref t) MsSql #
Instance details Defined in Napkin.Render.MsSql Methods renderSql :: MsSql -> Ref t -> Doc #
RenderSql (Ref t) Postgres #
Instance details Defined in Napkin.Render.Postgres Methods renderSql :: Postgres -> Ref t -> Doc #
RenderSql (Ref t) Redshift #
Instance details Defined in Napkin.Render.Redshift Methods renderSql :: Redshift -> Ref t -> Doc #
RenderSql (Ref t) Sqlite #
Instance details Defined in Napkin.Render.Sqlite Methods renderSql :: Sqlite -> Ref t -> Doc #
Cons (Ref a) (Ref a) Name Name #
Instance details Defined in Napkin.Types.Core Methods _Cons :: Prism (Ref a) (Ref a) (Name, Ref a) (Name, Ref a) #
Snoc (Ref a) (Ref a) Name Name #
Instance details Defined in Napkin.Types.Core Methods _Snoc :: Prism (Ref a) (Ref a) (Ref a, Name) (Ref a, Name) #
type Rep (Ref a) #
Instance details Defined in Napkin.Types.Core type Rep (Ref a) = D1 ('MetaData "Ref" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'True) (C1 ('MetaCons "Ref" 'PrefixI 'True) (S1 ('MetaSel ('Just "_unRef") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty Name))))

text2Ref :: Text -> Ref a #

newtype NormalizedTable #

Constructors

Normalized
Fields _normalizedRef :: Ref Table

Instances

Instances details

Generic NormalizedTable #
Instance details Defined in Napkin.Types.Core Associated Types type Rep NormalizedTable :: Type -> Type # Methods from :: NormalizedTable -> Rep NormalizedTable x # to :: Rep NormalizedTable x -> NormalizedTable #
Show NormalizedTable #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> NormalizedTable -> ShowS # show :: NormalizedTable -> String # showList :: [NormalizedTable] -> ShowS #
Buildable NormalizedTable #
Instance details Defined in Napkin.Types.Core Methods build :: NormalizedTable -> Builder #
Eq NormalizedTable #
Instance details Defined in Napkin.Types.Core Methods (==) :: NormalizedTable -> NormalizedTable -> Bool # (/=) :: NormalizedTable -> NormalizedTable -> Bool #
Ord NormalizedTable #
Instance details Defined in Napkin.Types.Core Methods compare :: NormalizedTable -> NormalizedTable -> Ordering # (<) :: NormalizedTable -> NormalizedTable -> Bool # (<=) :: NormalizedTable -> NormalizedTable -> Bool # (>) :: NormalizedTable -> NormalizedTable -> Bool # (>=) :: NormalizedTable -> NormalizedTable -> Bool # max :: NormalizedTable -> NormalizedTable -> NormalizedTable # min :: NormalizedTable -> NormalizedTable -> NormalizedTable #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) BigQuery #
Instance details Defined in Napkin.Run.BigQuery Methods execCommand :: MonadNapkin BigQuery m => BackendConn BigQuery -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) MsSql #
Instance details Defined in Napkin.Run.MsSql Methods execCommand :: MonadNapkin MsSql m => BackendConn MsSql -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) Postgres #
Instance details Defined in Napkin.Run.Postgres Methods execCommand :: MonadNapkin Postgres m => BackendConn Postgres -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) Redshift #
Instance details Defined in Napkin.Run.Redshift Methods execCommand :: MonadNapkin Redshift m => BackendConn Redshift -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) Sqlite #
Instance details Defined in Napkin.Run.Sqlite Methods execCommand :: MonadNapkin Sqlite m => BackendConn Sqlite -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
type Rep NormalizedTable #
Instance details Defined in Napkin.Types.Core type Rep NormalizedTable = D1 ('MetaData "NormalizedTable" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'True) (C1 ('MetaCons "Normalized" 'PrefixI 'True) (S1 ('MetaSel ('Just "_normalizedRef") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Ref Table))))

data ListedTableKind #

Constructors

Table
View
MaterializedView
External

Instances

Instances details

Data ListedTableKind #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ListedTableKind -> c ListedTableKind # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ListedTableKind # toConstr :: ListedTableKind -> Constr # dataTypeOf :: ListedTableKind -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ListedTableKind) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListedTableKind) # gmapT :: (forall b. Data b => b -> b) -> ListedTableKind -> ListedTableKind # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ListedTableKind -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ListedTableKind -> r # gmapQ :: (forall d. Data d => d -> u) -> ListedTableKind -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ListedTableKind -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ListedTableKind -> m ListedTableKind # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ListedTableKind -> m ListedTableKind # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ListedTableKind -> m ListedTableKind #
Read ListedTableKind #
Instance details Defined in Napkin.Types.Core Methods readsPrec :: Int -> ReadS ListedTableKind # readList :: ReadS [ListedTableKind] # readPrec :: ReadPrec ListedTableKind # readListPrec :: ReadPrec [ListedTableKind] #
Show ListedTableKind #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> ListedTableKind -> ShowS # show :: ListedTableKind -> String # showList :: [ListedTableKind] -> ShowS #
Buildable ListedTableKind #
Instance details Defined in Napkin.Types.Core Methods build :: ListedTableKind -> Builder #
Eq ListedTableKind #
Instance details Defined in Napkin.Types.Core Methods (==) :: ListedTableKind -> ListedTableKind -> Bool # (/=) :: ListedTableKind -> ListedTableKind -> Bool #
Ord ListedTableKind #
Instance details Defined in Napkin.Types.Core Methods compare :: ListedTableKind -> ListedTableKind -> Ordering # (<) :: ListedTableKind -> ListedTableKind -> Bool # (<=) :: ListedTableKind -> ListedTableKind -> Bool # (>) :: ListedTableKind -> ListedTableKind -> Bool # (>=) :: ListedTableKind -> ListedTableKind -> Bool # max :: ListedTableKind -> ListedTableKind -> ListedTableKind # min :: ListedTableKind -> ListedTableKind -> ListedTableKind #

data ListedTable #

Constructors

ListedTable
Fields _tableKind :: ListedTableKind _normalized :: NormalizedTable

Instances

Instances details

Buildable ListedTable #
Instance details Defined in Napkin.Types.Core Methods build :: ListedTable -> Builder #
Eq ListedTable #
Instance details Defined in Napkin.Types.Core Methods (==) :: ListedTable -> ListedTable -> Bool # (/=) :: ListedTable -> ListedTable -> Bool #
Ord ListedTable #
Instance details Defined in Napkin.Types.Core Methods compare :: ListedTable -> ListedTable -> Ordering # (<) :: ListedTable -> ListedTable -> Bool # (<=) :: ListedTable -> ListedTable -> Bool # (>) :: ListedTable -> ListedTable -> Bool # (>=) :: ListedTable -> ListedTable -> Bool # max :: ListedTable -> ListedTable -> ListedTable # min :: ListedTable -> ListedTable -> ListedTable #
Command ListTables (Set ListedTable) BigQuery #
Instance details Defined in Napkin.Run.BigQuery Methods execCommand :: MonadNapkin BigQuery m => BackendConn BigQuery -> ListTables -> m (Set ListedTable) #
Command ListTables (Set ListedTable) MsSql #
Instance details Defined in Napkin.Run.MsSql Methods execCommand :: MonadNapkin MsSql m => BackendConn MsSql -> ListTables -> m (Set ListedTable) #
Command ListTables (Set ListedTable) Postgres #
Instance details Defined in Napkin.Run.Postgres Methods execCommand :: MonadNapkin Postgres m => BackendConn Postgres -> ListTables -> m (Set ListedTable) #
Command ListTables (Set ListedTable) Redshift #
Instance details Defined in Napkin.Run.Redshift Methods execCommand :: MonadNapkin Redshift m => BackendConn Redshift -> ListTables -> m (Set ListedTable) #
Command ListTables (Set ListedTable) Sqlite #
Instance details Defined in Napkin.Run.Sqlite Methods execCommand :: MonadNapkin Sqlite m => BackendConn Sqlite -> ListTables -> m (Set ListedTable) #

newtype TemporaryTableName #

Constructors

TemporaryTableName (Ref Table)

newtype SpecTableName #

The way to refer to tasks in the spec. With renaming these can then refer to tables in a database. Once renamed, they should never be repacked into newtype. Be careful to avoid use of Constructor SpecTableName internally in Napkin. Ideally, baseTableName will only be used when renaming, but this is less of a concern.

Constructors

SpecTableName
Fields baseTableName :: Ref Table

Instances

Instances details

FromJSON SpecTableName #
Instance details Defined in Napkin.Types.Core Methods parseJSON :: Value -> Parser SpecTableName # parseJSONList :: Value -> Parser [SpecTableName] #
FromJSONKey SpecTableName #
Instance details Defined in Napkin.Types.Core Methods fromJSONKey :: FromJSONKeyFunction SpecTableName # fromJSONKeyList :: FromJSONKeyFunction [SpecTableName] #
ToJSON SpecTableName #
Instance details Defined in Napkin.Types.Core Methods toJSON :: SpecTableName -> Value # toEncoding :: SpecTableName -> Encoding # toJSONList :: [SpecTableName] -> Value # toEncodingList :: [SpecTableName] -> Encoding #
ToJSONKey SpecTableName #
Instance details Defined in Napkin.Types.Core Methods toJSONKey :: ToJSONKeyFunction SpecTableName # toJSONKeyList :: ToJSONKeyFunction [SpecTableName] #
Data SpecTableName #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpecTableName -> c SpecTableName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpecTableName # toConstr :: SpecTableName -> Constr # dataTypeOf :: SpecTableName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpecTableName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpecTableName) # gmapT :: (forall b. Data b => b -> b) -> SpecTableName -> SpecTableName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpecTableName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpecTableName -> r # gmapQ :: (forall d. Data d => d -> u) -> SpecTableName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpecTableName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpecTableName -> m SpecTableName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecTableName -> m SpecTableName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecTableName -> m SpecTableName #
IsString SpecTableName #
Instance details Defined in Napkin.Types.Core Methods fromString :: String -> SpecTableName #
Semigroup SpecTableName #
Instance details Defined in Napkin.Types.Core Methods (<>) :: SpecTableName -> SpecTableName -> SpecTableName # sconcat :: NonEmpty SpecTableName -> SpecTableName # stimes :: Integral b => b -> SpecTableName -> SpecTableName #
Generic SpecTableName #
Instance details Defined in Napkin.Types.Core Associated Types type Rep SpecTableName :: Type -> Type # Methods from :: SpecTableName -> Rep SpecTableName x # to :: Rep SpecTableName x -> SpecTableName #
Show SpecTableName #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> SpecTableName -> ShowS # show :: SpecTableName -> String # showList :: [SpecTableName] -> ShowS #
Buildable SpecTableName #
Instance details Defined in Napkin.Types.Core Methods build :: SpecTableName -> Builder #
Eq SpecTableName #
Instance details Defined in Napkin.Types.Core Methods (==) :: SpecTableName -> SpecTableName -> Bool # (/=) :: SpecTableName -> SpecTableName -> Bool #
Ord SpecTableName #
Instance details Defined in Napkin.Types.Core Methods compare :: SpecTableName -> SpecTableName -> Ordering # (<) :: SpecTableName -> SpecTableName -> Bool # (<=) :: SpecTableName -> SpecTableName -> Bool # (>) :: SpecTableName -> SpecTableName -> Bool # (>=) :: SpecTableName -> SpecTableName -> Bool # max :: SpecTableName -> SpecTableName -> SpecTableName # min :: SpecTableName -> SpecTableName -> SpecTableName #
AsRelation SpecTableName #
Instance details Defined in Napkin.Types.Core Methods asRelation :: SpecTableName -> Relation #
TableRef SpecTableName #
Instance details Defined in Napkin.Types.Core Methods tableRef :: Lens' SpecTableName (Ref Table) #
(BeamMigrateSqlBackend bk, FromBackendRow bk Text) => FromBackendRow bk SpecTableName #
Instance details Defined in Napkin.Metadata.Instances Methods fromBackendRow :: FromBackendRowM bk SpecTableName # valuesNeeded :: Proxy bk -> Proxy SpecTableName -> Int #
HasSqlValueSyntax bk Text => HasSqlValueSyntax bk SpecTableName #
Instance details Defined in Napkin.Metadata.Instances Methods sqlValueSyntax :: SpecTableName -> bk #
BeamSqlBackend bk => HasSqlEqualityCheck bk SpecTableName #
Instance details Defined in Napkin.Metadata.Instances Methods sqlEqE :: Proxy SpecTableName -> Proxy bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk # sqlNeqE :: Proxy SpecTableName -> Proxy bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk # sqlEqTriE :: Proxy SpecTableName -> Proxy bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk # sqlNeqTriE :: Proxy SpecTableName -> Proxy bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk -> BeamSqlBackendExpressionSyntax bk #
BeamMigrateSqlBackend bk => HasDefaultSqlDataType bk SpecTableName #
Instance details Defined in Napkin.Metadata.Instances Methods defaultSqlDataType :: Proxy SpecTableName -> Proxy bk -> Bool -> BeamSqlBackendDataTypeSyntax bk # defaultSqlDataTypeConstraints :: Proxy SpecTableName -> Proxy bk -> Bool -> [FieldCheck] #
BeamSqlBackend bk => DataTypeForBackend bk SpecTableName #
Instance details Defined in Napkin.Metadata.Migrations Methods dbType :: DataType bk SpecTableName #
type Rep SpecTableName #
Instance details Defined in Napkin.Types.Core type Rep SpecTableName = D1 ('MetaData "SpecTableName" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'True) (C1 ('MetaCons "SpecTableName" 'PrefixI 'True) (S1 ('MetaSel ('Just "baseTableName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Ref Table))))

useSpecName :: SpecTableName -> Ref Table #

An alias for baseTableName to use when renaming. As renaming is the proper way to unpack a SpecTableName, use this when unpacking a SpecTableName for renaming (or potential renaming). A little semantic flag to demarcate proper usages.

class IsRef a where #

Class of string-like types that can be interpreted as Refs

Methods

ref :: forall b. a -> Ref b #

Instances

Instances details

IsRef Name #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). Name -> Ref b #
IsRef Text #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). Text -> Ref b #
IsRef String #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). String -> Ref b #
IsRef (NonEmpty Name) #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). NonEmpty Name -> Ref b #
IsRef [Name] #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). [Name] -> Ref b #
IsRef (Ref a) #
Instance details Defined in Napkin.Types.Core Methods ref :: forall {k} (b :: k). Ref a -> Ref b #

refComponentCount :: Ref a -> Int #

Return the number of Names in the Ref.

stringRefIso :: Iso' String (Ref a) #

refStringIso :: Iso' (Ref a) String #

stringRef :: String -> Ref a #

textRef :: Text -> Ref a #

nameRef :: Name -> Ref a #

namesRef :: [Name] -> Ref a #

sNamesRef :: NonEmpty Name -> Ref a #

sNameRef :: Name -> Ref a #

refString :: Ref t -> String #

specTableString :: SpecTableName -> String #

refText :: Ref t -> Text #

specTableText :: SpecTableName -> Text #

retagRef :: Ref t -> Ref a #

appendRef :: Ref a -> Name -> Ref a #

star :: SExp #

data Table #

Instances

Instances details

Data Table #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Table -> c Table # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Table # toConstr :: Table -> Constr # dataTypeOf :: Table -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Table) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Table) # gmapT :: (forall b. Data b => b -> b) -> Table -> Table # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Table -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Table -> r # gmapQ :: (forall d. Data d => d -> u) -> Table -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Table -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Table -> m Table # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Table -> m Table # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Table -> m Table #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) BigQuery #
Instance details Defined in Napkin.Run.BigQuery Methods execCommand :: MonadNapkin BigQuery m => BackendConn BigQuery -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) MsSql #
Instance details Defined in Napkin.Run.MsSql Methods execCommand :: MonadNapkin MsSql m => BackendConn MsSql -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) Postgres #
Instance details Defined in Napkin.Run.Postgres Methods execCommand :: MonadNapkin Postgres m => BackendConn Postgres -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) Redshift #
Instance details Defined in Napkin.Run.Redshift Methods execCommand :: MonadNapkin Redshift m => BackendConn Redshift -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
Command NormalizeTableNames (Map (Ref Table) NormalizedTable) Sqlite #
Instance details Defined in Napkin.Run.Sqlite Methods execCommand :: MonadNapkin Sqlite m => BackendConn Sqlite -> NormalizeTableNames -> m (Map (Ref Table) NormalizedTable) #
TableRenamer (Alias Table) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Alias Table -> Alias Table #
TableRenamer (Selected Table) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Selected Table -> Selected Table #
TableRef (Ref Table) #
Instance details Defined in Napkin.Types.Core Methods tableRef :: Lens' (Ref Table) (Ref Table) #
HasDeps (Ref Table) #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: Ref Table -> Set (Ref Table) # traverseDependencies :: Fold (Ref Table) (Ref Table) #
TableRenamer (Ref Table) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Ref Table -> Ref Table #

data Function #

Instances

Instances details

Data Function #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Function -> c Function # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Function # toConstr :: Function -> Constr # dataTypeOf :: Function -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Function) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Function) # gmapT :: (forall b. Data b => b -> b) -> Function -> Function # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Function -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Function -> r # gmapQ :: (forall d. Data d => d -> u) -> Function -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Function -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Function -> m Function # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Function -> m Function # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Function -> m Function #
IsString (Ref Function) #
Instance details Defined in Napkin.Types.Core Methods fromString :: String -> Ref Function #
FoldCase (Ref Function) #
Instance details Defined in Napkin.Types.Core Methods foldCase :: Ref Function -> Ref Function # foldCaseList :: [Ref Function] -> [Ref Function]

keywordRef :: String -> Ref Function #

some functions are keywords and they cannot be enclosed into default quotes for idens. (e.g. exists or not exists - by default IsString Ref wraps all idens in quotes default for Dialect)

data Selected a #

Select something and give it a name; e.g. (my_field as foo)

Constructors

Selected
Fields _selectRef :: Ref a _selectItem :: a

Instances

Instances details

Foldable Selected #
Instance details Defined in Napkin.Types.Core Methods fold :: Monoid m => Selected m -> m # foldMap :: Monoid m => (a -> m) -> Selected a -> m # foldMap' :: Monoid m => (a -> m) -> Selected a -> m # foldr :: (a -> b -> b) -> b -> Selected a -> b # foldr' :: (a -> b -> b) -> b -> Selected a -> b # foldl :: (b -> a -> b) -> b -> Selected a -> b # foldl' :: (b -> a -> b) -> b -> Selected a -> b # foldr1 :: (a -> a -> a) -> Selected a -> a # foldl1 :: (a -> a -> a) -> Selected a -> a # toList :: Selected a -> [a] # null :: Selected a -> Bool # length :: Selected a -> Int # elem :: Eq a => a -> Selected a -> Bool # maximum :: Ord a => Selected a -> a # minimum :: Ord a => Selected a -> a # sum :: Num a => Selected a -> a # product :: Num a => Selected a -> a #
WithName Selected #
Instance details Defined in Napkin.Types.Core Methods as :: b -> Ref b -> Selected b #
Lift a => Lift (Selected a :: Type) #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Selected a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Selected a -> Code m (Selected a) #
Data a => Data (Selected a) #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Selected a -> c (Selected a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Selected a) # toConstr :: Selected a -> Constr # dataTypeOf :: Selected a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Selected a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Selected a)) # gmapT :: (forall b. Data b => b -> b) -> Selected a -> Selected a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Selected a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Selected a -> r # gmapQ :: (forall d. Data d => d -> u) -> Selected a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Selected a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Selected a -> m (Selected a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Selected a -> m (Selected a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Selected a -> m (Selected a) #
Generic (Selected a) #
Instance details Defined in Napkin.Types.Core Associated Types type Rep (Selected a) :: Type -> Type # Methods from :: Selected a -> Rep (Selected a) x # to :: Rep (Selected a) x -> Selected a #
Show a => Show (Selected a) #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Selected a -> ShowS # show :: Selected a -> String # showList :: [Selected a] -> ShowS #
NFData a => NFData (Selected a) #
Instance details Defined in Napkin.Types.Core Methods rnf :: Selected a -> () #
Eq a => Eq (Selected a) #
Instance details Defined in Napkin.Types.Core Methods (==) :: Selected a -> Selected a -> Bool # (/=) :: Selected a -> Selected a -> Bool #
Ord a => Ord (Selected a) #
Instance details Defined in Napkin.Types.Core Methods compare :: Selected a -> Selected a -> Ordering # (<) :: Selected a -> Selected a -> Bool # (<=) :: Selected a -> Selected a -> Bool # (>) :: Selected a -> Selected a -> Bool # (>=) :: Selected a -> Selected a -> Bool # max :: Selected a -> Selected a -> Selected a # min :: Selected a -> Selected a -> Selected a #
HasDeps a => HasDeps (Selected a) #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: Selected a -> Set (Ref Table) # traverseDependencies :: Fold (Selected a) (Ref Table) #
FunRenamer (Selected Query) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> Selected Query -> Selected Query #
FunRenamer (Selected Relation) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> Selected Relation -> Selected Relation #
FunctionTransformer (Selected Query) #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> Selected Query -> Selected Query #
FunctionTransformer (Selected Relation) #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> Selected Relation -> Selected Relation #
TableRenamer (Selected Query) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Selected Query -> Selected Query #
TableRenamer (Selected Relation) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Selected Relation -> Selected Relation #
TableRenamer (Selected Table) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Selected Table -> Selected Table #
type Rep (Selected a) #
Instance details Defined in Napkin.Types.Core type Rep (Selected a) = D1 ('MetaData "Selected" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "Selected" 'PrefixI 'True) (S1 ('MetaSel ('Just "_selectRef") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Ref a)) :*: S1 ('MetaSel ('Just "_selectItem") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

data Alias a #

Like selected, but aliasing is optional

Constructors

Alias
Fields _aliasRef :: Maybe (Ref a) _aliasItem :: a

Instances

Instances details

Foldable Alias #
Instance details Defined in Napkin.Types.Core Methods fold :: Monoid m => Alias m -> m # foldMap :: Monoid m => (a -> m) -> Alias a -> m # foldMap' :: Monoid m => (a -> m) -> Alias a -> m # foldr :: (a -> b -> b) -> b -> Alias a -> b # foldr' :: (a -> b -> b) -> b -> Alias a -> b # foldl :: (b -> a -> b) -> b -> Alias a -> b # foldl' :: (b -> a -> b) -> b -> Alias a -> b # foldr1 :: (a -> a -> a) -> Alias a -> a # foldl1 :: (a -> a -> a) -> Alias a -> a # toList :: Alias a -> [a] # null :: Alias a -> Bool # length :: Alias a -> Int # elem :: Eq a => a -> Alias a -> Bool # maximum :: Ord a => Alias a -> a # minimum :: Ord a => Alias a -> a # sum :: Num a => Alias a -> a # product :: Num a => Alias a -> a #
WithName Alias #
Instance details Defined in Napkin.Types.Core Methods as :: b -> Ref b -> Alias b #
Lift a => Lift (Alias a :: Type) #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Alias a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Alias a -> Code m (Alias a) #
Data a => Data (Alias a) #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alias a -> c (Alias a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alias a) # toConstr :: Alias a -> Constr # dataTypeOf :: Alias a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alias a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alias a)) # gmapT :: (forall b. Data b => b -> b) -> Alias a -> Alias a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alias a -> r # gmapQ :: (forall d. Data d => d -> u) -> Alias a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alias a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alias a -> m (Alias a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alias a -> m (Alias a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alias a -> m (Alias a) #
Generic (Alias a) #
Instance details Defined in Napkin.Types.Core Associated Types type Rep (Alias a) :: Type -> Type # Methods from :: Alias a -> Rep (Alias a) x # to :: Rep (Alias a) x -> Alias a #
Show a => Show (Alias a) #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Alias a -> ShowS # show :: Alias a -> String # showList :: [Alias a] -> ShowS #
NFData a => NFData (Alias a) #
Instance details Defined in Napkin.Types.Core Methods rnf :: Alias a -> () #
Eq a => Eq (Alias a) #
Instance details Defined in Napkin.Types.Core Methods (==) :: Alias a -> Alias a -> Bool # (/=) :: Alias a -> Alias a -> Bool #
Ord a => Ord (Alias a) #
Instance details Defined in Napkin.Types.Core Methods compare :: Alias a -> Alias a -> Ordering # (<) :: Alias a -> Alias a -> Bool # (<=) :: Alias a -> Alias a -> Bool # (>) :: Alias a -> Alias a -> Bool # (>=) :: Alias a -> Alias a -> Bool # max :: Alias a -> Alias a -> Alias a # min :: Alias a -> Alias a -> Alias a #
HasDeps (Alias SExp) #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: Alias SExp -> Set (Ref Table) # traverseDependencies :: Fold (Alias SExp) (Ref Table) #
FunRenamer (Alias SExp) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> Alias SExp -> Alias SExp #
FunctionTransformer (Alias SExp) #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> Alias SExp -> Alias SExp #
TableRenamer (Alias SExp) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Alias SExp -> Alias SExp #
TableRenamer (Alias Table) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Alias Table -> Alias Table #
RenderSql a BigQuery => RenderSql (Alias a) BigQuery #
Instance details Defined in Napkin.Render.BigQuery Methods renderSql :: BigQuery -> Alias a -> Doc #
RenderSql a MsSql => RenderSql (Alias a) MsSql #
Instance details Defined in Napkin.Render.MsSql Methods renderSql :: MsSql -> Alias a -> Doc #
RenderSql a Postgres => RenderSql (Alias a) Postgres #
Instance details Defined in Napkin.Render.Postgres Methods renderSql :: Postgres -> Alias a -> Doc #
RenderSql a Redshift => RenderSql (Alias a) Redshift #
Instance details Defined in Napkin.Render.Redshift Methods renderSql :: Redshift -> Alias a -> Doc #
RenderSql a Sqlite => RenderSql (Alias a) Sqlite #
Instance details Defined in Napkin.Render.Sqlite Methods renderSql :: Sqlite -> Alias a -> Doc #
RenderSql (Alias SExp) backend => RenderSql [Alias SExp] backend #
Instance details Defined in Napkin.Render.Common Methods renderSql :: backend -> [Alias SExp] -> Doc #
type Rep (Alias a) #
Instance details Defined in Napkin.Types.Core type Rep (Alias a) = D1 ('MetaData "Alias" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "Alias" 'PrefixI 'True) (S1 ('MetaSel ('Just "_aliasRef") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Ref a))) :*: S1 ('MetaSel ('Just "_aliasItem") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

nonAlias :: a -> Alias a #

class WithName a where #

Methods

as :: b -> Ref b -> a b #

e.g. var "foo" as "bar"

Instances

Instances details

WithName Alias #
Instance details Defined in Napkin.Types.Core Methods as :: b -> Ref b -> Alias b #
WithName Selected #
Instance details Defined in Napkin.Types.Core Methods as :: b -> Ref b -> Selected b #

sa :: WithName a => Ref b -> b -> a b #

Flipped as

selectToAlias :: Selected a -> Alias a #

data StructField #

Constructors

StructFieldSharp Int
StructFieldNamed Text

Instances

Instances details

Data StructField #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StructField -> c StructField # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c StructField # toConstr :: StructField -> Constr # dataTypeOf :: StructField -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c StructField) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StructField) # gmapT :: (forall b. Data b => b -> b) -> StructField -> StructField # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StructField -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StructField -> r # gmapQ :: (forall d. Data d => d -> u) -> StructField -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> StructField -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> StructField -> m StructField # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StructField -> m StructField # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StructField -> m StructField #
Generic StructField #
Instance details Defined in Napkin.Types.Core Associated Types type Rep StructField :: Type -> Type # Methods from :: StructField -> Rep StructField x # to :: Rep StructField x -> StructField #
Read StructField #
Instance details Defined in Napkin.Types.Core Methods readsPrec :: Int -> ReadS StructField # readList :: ReadS [StructField] # readPrec :: ReadPrec StructField # readListPrec :: ReadPrec [StructField] #
Show StructField #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> StructField -> ShowS # show :: StructField -> String # showList :: [StructField] -> ShowS #
NFData StructField #
Instance details Defined in Napkin.Types.Core Methods rnf :: StructField -> () #
Eq StructField #
Instance details Defined in Napkin.Types.Core Methods (==) :: StructField -> StructField -> Bool # (/=) :: StructField -> StructField -> Bool #
Ord StructField #
Instance details Defined in Napkin.Types.Core Methods compare :: StructField -> StructField -> Ordering # (<) :: StructField -> StructField -> Bool # (<=) :: StructField -> StructField -> Bool # (>) :: StructField -> StructField -> Bool # (>=) :: StructField -> StructField -> Bool # max :: StructField -> StructField -> StructField # min :: StructField -> StructField -> StructField #
Lift StructField #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => StructField -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => StructField -> Code m StructField #
type Rep StructField #
Instance details Defined in Napkin.Types.Core type Rep StructField = D1 ('MetaData "StructField" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "StructFieldSharp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: C1 ('MetaCons "StructFieldNamed" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

data Value #

Constructors

VDouble !Double
VInt !Int64
VBool !Bool
VDate !Day
VDateTime !UTCTime
VText !SrcLitStr
VBinary !ByteString
VInterval !Interval
VNull
VDatePart !DatePart

Instances

Instances details

Data Value #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Value -> c Value # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Value # toConstr :: Value -> Constr # dataTypeOf :: Value -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Value) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value) # gmapT :: (forall b. Data b => b -> b) -> Value -> Value # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQ :: (forall d. Data d => d -> u) -> Value -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Value -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value #
Generic Value #
Instance details Defined in Napkin.Types.Core Associated Types type Rep Value :: Type -> Type # Methods from :: Value -> Rep Value x # to :: Rep Value x -> Value #
Show Value #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #
NFData Value #
Instance details Defined in Napkin.Types.Core Methods rnf :: Value -> () #
Eq Value #
Instance details Defined in Napkin.Types.Core Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Ord Value #
Instance details Defined in Napkin.Types.Core Methods compare :: Value -> Value -> Ordering # (<) :: Value -> Value -> Bool # (<=) :: Value -> Value -> Bool # (>) :: Value -> Value -> Bool # (>=) :: Value -> Value -> Bool # max :: Value -> Value -> Value # min :: Value -> Value -> Value #
Val Value #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value Value #
FromField Value #
Instance details Defined in Napkin.Run.Sqlite Methods fromField :: FieldParser Value #
Lift Value #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Value -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Value -> Code m Value #
FromField (Named Value) #
Instance details Defined in Napkin.Run.PGCommon Methods fromField :: FieldParser (Named Value) #
FromRow (Map Text Value) #
Instance details Defined in Napkin.Run.PGCommon Methods fromRow :: RowParser (Map Text Value) #
type Rep Value #
Instance details Defined in Napkin.Types.Core type Rep Value = D1 ('MetaData "Value" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (((C1 ('MetaCons "VDouble" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 Double)) :+: C1 ('MetaCons "VInt" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 Int64))) :+: (C1 ('MetaCons "VBool" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)) :+: (C1 ('MetaCons "VDate" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Day)) :+: C1 ('MetaCons "VDateTime" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 UTCTime))))) :+: ((C1 ('MetaCons "VText" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SrcLitStr)) :+: C1 ('MetaCons "VBinary" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 ByteString))) :+: (C1 ('MetaCons "VInterval" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Interval)) :+: (C1 ('MetaCons "VNull" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "VDatePart" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 DatePart))))))

newtype Interval #

Intervals could internally make use of expressions

Constructors

Interval
Fields _unInterval :: [(SExp, DatePart)]

Instances

Instances details

Data Interval #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Interval -> c Interval # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Interval # toConstr :: Interval -> Constr # dataTypeOf :: Interval -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Interval) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Interval) # gmapT :: (forall b. Data b => b -> b) -> Interval -> Interval # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Interval -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Interval -> r # gmapQ :: (forall d. Data d => d -> u) -> Interval -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Interval -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Interval -> m Interval # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval -> m Interval # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval -> m Interval #
Generic Interval #
Instance details Defined in Napkin.Types.Core Associated Types type Rep Interval :: Type -> Type # Methods from :: Interval -> Rep Interval x # to :: Rep Interval x -> Interval #
Show Interval #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Interval -> ShowS # show :: Interval -> String # showList :: [Interval] -> ShowS #
NFData Interval #
Instance details Defined in Napkin.Types.Core Methods rnf :: Interval -> () #
Eq Interval #
Instance details Defined in Napkin.Types.Core Methods (==) :: Interval -> Interval -> Bool # (/=) :: Interval -> Interval -> Bool #
Ord Interval #
Instance details Defined in Napkin.Types.Core Methods compare :: Interval -> Interval -> Ordering # (<) :: Interval -> Interval -> Bool # (<=) :: Interval -> Interval -> Bool # (>) :: Interval -> Interval -> Bool # (>=) :: Interval -> Interval -> Bool # max :: Interval -> Interval -> Interval # min :: Interval -> Interval -> Interval #
Lift Interval #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Interval -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Interval -> Code m Interval #
type Rep Interval #
Instance details Defined in Napkin.Types.Core type Rep Interval = D1 ('MetaData "Interval" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'True) (C1 ('MetaCons "Interval" 'PrefixI 'True) (S1 ('MetaSel ('Just "_unInterval") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(SExp, DatePart)])))

data IntInterval #

A simpler sub-variant to Interval that fits certain cases better. Maps onto Interval underneath.

Constructors

IntInterval SExp DatePart

Instances

Instances details

Data IntInterval #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntInterval -> c IntInterval # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntInterval # toConstr :: IntInterval -> Constr # dataTypeOf :: IntInterval -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntInterval) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntInterval) # gmapT :: (forall b. Data b => b -> b) -> IntInterval -> IntInterval # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntInterval -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntInterval -> r # gmapQ :: (forall d. Data d => d -> u) -> IntInterval -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IntInterval -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntInterval -> m IntInterval # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntInterval -> m IntInterval # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntInterval -> m IntInterval #
Show IntInterval #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> IntInterval -> ShowS # show :: IntInterval -> String # showList :: [IntInterval] -> ShowS #
Eq IntInterval #
Instance details Defined in Napkin.Types.Core Methods (==) :: IntInterval -> IntInterval -> Bool # (/=) :: IntInterval -> IntInterval -> Bool #
Ord IntInterval #
Instance details Defined in Napkin.Types.Core Methods compare :: IntInterval -> IntInterval -> Ordering # (<) :: IntInterval -> IntInterval -> Bool # (<=) :: IntInterval -> IntInterval -> Bool # (>) :: IntInterval -> IntInterval -> Bool # (>=) :: IntInterval -> IntInterval -> Bool # max :: IntInterval -> IntInterval -> IntInterval # min :: IntInterval -> IntInterval -> IntInterval #
Val IntInterval #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value IntInterval #

data ArrayBase #

BigQuery array index can be 0-based or 1-based

Constructors

ArrayBase0
ArrayBase1

Instances

Instances details

Data ArrayBase #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArrayBase -> c ArrayBase # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArrayBase # toConstr :: ArrayBase -> Constr # dataTypeOf :: ArrayBase -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ArrayBase) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayBase) # gmapT :: (forall b. Data b => b -> b) -> ArrayBase -> ArrayBase # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArrayBase -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArrayBase -> r # gmapQ :: (forall d. Data d => d -> u) -> ArrayBase -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ArrayBase -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArrayBase -> m ArrayBase # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArrayBase -> m ArrayBase # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArrayBase -> m ArrayBase #
Generic ArrayBase #
Instance details Defined in Napkin.Types.Core Associated Types type Rep ArrayBase :: Type -> Type # Methods from :: ArrayBase -> Rep ArrayBase x # to :: Rep ArrayBase x -> ArrayBase #
Show ArrayBase #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> ArrayBase -> ShowS # show :: ArrayBase -> String # showList :: [ArrayBase] -> ShowS #
NFData ArrayBase #
Instance details Defined in Napkin.Types.Core Methods rnf :: ArrayBase -> () #
Eq ArrayBase #
Instance details Defined in Napkin.Types.Core Methods (==) :: ArrayBase -> ArrayBase -> Bool # (/=) :: ArrayBase -> ArrayBase -> Bool #
Ord ArrayBase #
Instance details Defined in Napkin.Types.Core Methods compare :: ArrayBase -> ArrayBase -> Ordering # (<) :: ArrayBase -> ArrayBase -> Bool # (<=) :: ArrayBase -> ArrayBase -> Bool # (>) :: ArrayBase -> ArrayBase -> Bool # (>=) :: ArrayBase -> ArrayBase -> Bool # max :: ArrayBase -> ArrayBase -> ArrayBase # min :: ArrayBase -> ArrayBase -> ArrayBase #
Lift ArrayBase #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => ArrayBase -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ArrayBase -> Code m ArrayBase #
type Rep ArrayBase #
Instance details Defined in Napkin.Types.Core type Rep ArrayBase = D1 ('MetaData "ArrayBase" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "ArrayBase0" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ArrayBase1" 'PrefixI 'False) (U1 :: Type -> Type))

data Nullability #

Constructors

Nullable
NotNull

Instances

Instances details

Data Nullability #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Nullability -> c Nullability # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Nullability # toConstr :: Nullability -> Constr # dataTypeOf :: Nullability -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Nullability) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Nullability) # gmapT :: (forall b. Data b => b -> b) -> Nullability -> Nullability # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Nullability -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Nullability -> r # gmapQ :: (forall d. Data d => d -> u) -> Nullability -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Nullability -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Nullability -> m Nullability # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Nullability -> m Nullability # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Nullability -> m Nullability #
Generic Nullability #
Instance details Defined in Napkin.Types.Core Associated Types type Rep Nullability :: Type -> Type # Methods from :: Nullability -> Rep Nullability x # to :: Rep Nullability x -> Nullability #
Show Nullability #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Nullability -> ShowS # show :: Nullability -> String # showList :: [Nullability] -> ShowS #
NFData Nullability #
Instance details Defined in Napkin.Types.Core Methods rnf :: Nullability -> () #
Eq Nullability #
Instance details Defined in Napkin.Types.Core Methods (==) :: Nullability -> Nullability -> Bool # (/=) :: Nullability -> Nullability -> Bool #
Ord Nullability #
Instance details Defined in Napkin.Types.Core Methods compare :: Nullability -> Nullability -> Ordering # (<) :: Nullability -> Nullability -> Bool # (<=) :: Nullability -> Nullability -> Bool # (>) :: Nullability -> Nullability -> Bool # (>=) :: Nullability -> Nullability -> Bool # max :: Nullability -> Nullability -> Nullability # min :: Nullability -> Nullability -> Nullability #
Lift Nullability #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Nullability -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Nullability -> Code m Nullability #
type Rep Nullability #
Instance details Defined in Napkin.Types.Core type Rep Nullability = D1 ('MetaData "Nullability" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "Nullable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NotNull" 'PrefixI 'False) (U1 :: Type -> Type))

data Field #

Constructors

Field Nullability Type

data SExp #

Constructors

Lit Value
Var (Ref SExp)
ArraySelect Query
ArrayItem
Fields _sExp_ArrayItem_base :: ArrayBase _sExp_ArrayItem_null :: Nullability _sExp_ArrayItem_arr :: SExp _sExp_ArrayItem_idx :: SExp
Array
Fields _sExp_Array_itemType :: Maybe Type _sExp_Array_items :: [SExp]
Struct
Fields _sExp_Struct_types :: Maybe (OMap StructField Type) _sExp_Struct_values :: OMap StructField SExp
FieldAccess
Fields _sExp_fieldAccess_base :: SExp _sExp_fieldAccess_name :: StructField
Extern ExternFun	external function call
Case [(SExp, SExp)] SExp	case with a final default
ExceptColumns SExp [Ref SExp]	t.* EXCEPT(a,b,c)
SubQuery Query
NativeExpr NativeExpr

Instances

Instances details

Data SExp #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SExp -> c SExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SExp # toConstr :: SExp -> Constr # dataTypeOf :: SExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SExp) # gmapT :: (forall b. Data b => b -> b) -> SExp -> SExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SExp -> r # gmapQ :: (forall d. Data d => d -> u) -> SExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SExp -> m SExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SExp -> m SExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SExp -> m SExp #
Generic SExp #
Instance details Defined in Napkin.Types.Core Associated Types type Rep SExp :: Type -> Type # Methods from :: SExp -> Rep SExp x # to :: Rep SExp x -> SExp #
Num SExp #
Instance details Defined in Napkin.Untyped.Ops Methods (+) :: SExp -> SExp -> SExp # (-) :: SExp -> SExp -> SExp # (*) :: SExp -> SExp -> SExp # negate :: SExp -> SExp # abs :: SExp -> SExp # signum :: SExp -> SExp # fromInteger :: Integer -> SExp #
Fractional SExp #
Instance details Defined in Napkin.Untyped.Ops Methods (/) :: SExp -> SExp -> SExp # recip :: SExp -> SExp # fromRational :: Rational -> SExp #
Show SExp #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> SExp -> ShowS # show :: SExp -> String # showList :: [SExp] -> ShowS #
NFData SExp #
Instance details Defined in Napkin.Types.Core Methods rnf :: SExp -> () #
Eq SExp #
Instance details Defined in Napkin.Types.Core Methods (==) :: SExp -> SExp -> Bool # (/=) :: SExp -> SExp -> Bool #
Ord SExp #
Instance details Defined in Napkin.Types.Core Methods compare :: SExp -> SExp -> Ordering # (<) :: SExp -> SExp -> Bool # (<=) :: SExp -> SExp -> Bool # (>) :: SExp -> SExp -> Bool # (>=) :: SExp -> SExp -> Bool # max :: SExp -> SExp -> SExp # min :: SExp -> SExp -> SExp #
HasDeps SExp #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: SExp -> Set (Ref Table) # traverseDependencies :: Fold SExp (Ref Table) #
FunRenamer SExp #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> SExp -> SExp #
FunctionTransformer SExp #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> SExp -> SExp #
TableRenamer SExp #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> SExp -> SExp #
RenderSql SExp BigQuery #
Instance details Defined in Napkin.Render.BigQuery Methods renderSql :: BigQuery -> SExp -> Doc #
RenderSql SExp MsSql #
Instance details Defined in Napkin.Render.MsSql Methods renderSql :: MsSql -> SExp -> Doc #
RenderSql SExp Postgres #
Instance details Defined in Napkin.Render.Postgres Methods renderSql :: Postgres -> SExp -> Doc #
RenderSql SExp Redshift #
Instance details Defined in Napkin.Render.Redshift Methods renderSql :: Redshift -> SExp -> Doc #
RenderSql SExp Sqlite #
Instance details Defined in Napkin.Render.Sqlite Methods renderSql :: Sqlite -> SExp -> Doc #
Lift SExp #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => SExp -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => SExp -> Code m SExp #
HasDeps (Alias SExp) #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: Alias SExp -> Set (Ref Table) # traverseDependencies :: Fold (Alias SExp) (Ref Table) #
FunRenamer (Alias SExp) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> Alias SExp -> Alias SExp #
FunctionTransformer (Alias SExp) #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> Alias SExp -> Alias SExp #
TableRenamer (Alias SExp) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Alias SExp -> Alias SExp #
RenderSql (Alias SExp) backend => RenderSql [Alias SExp] backend #
Instance details Defined in Napkin.Render.Common Methods renderSql :: backend -> [Alias SExp] -> Doc #
HasDeps (OMap Name SExp) #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: OMap Name SExp -> Set (Ref Table) # traverseDependencies :: Fold (OMap Name SExp) (Ref Table) #
type Rep SExp #
Instance details Defined in Napkin.Types.Core type Rep SExp = D1 ('MetaData "SExp" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (((C1 ('MetaCons "Lit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Value)) :+: (C1 ('MetaCons "Var" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Ref SExp))) :+: C1 ('MetaCons "ArraySelect" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Query)))) :+: (C1 ('MetaCons "ArrayItem" 'PrefixI 'True) ((S1 ('MetaSel ('Just "_sExp_ArrayItem_base") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ArrayBase) :: S1 ('MetaSel ('Just "_sExp_ArrayItem_null") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Nullability)) :: (S1 ('MetaSel ('Just "_sExp_ArrayItem_arr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp) :: S1 ('MetaSel ('Just "_sExp_ArrayItem_idx") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp))) :+: (C1 ('MetaCons "Array" 'PrefixI 'True) (S1 ('MetaSel ('Just "_sExp_Array_itemType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Type)) :: S1 ('MetaSel ('Just "_sExp_Array_items") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [SExp])) :+: C1 ('MetaCons "Struct" 'PrefixI 'True) (S1 ('MetaSel ('Just "_sExp_Struct_types") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (OMap StructField Type))) :: S1 ('MetaSel ('Just "_sExp_Struct_values") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (OMap StructField SExp)))))) :+: ((C1 ('MetaCons "FieldAccess" 'PrefixI 'True) (S1 ('MetaSel ('Just "_sExp_fieldAccess_base") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp) :: S1 ('MetaSel ('Just "_sExp_fieldAccess_name") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StructField)) :+: (C1 ('MetaCons "Extern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ExternFun)) :+: C1 ('MetaCons "Case" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(SExp, SExp)]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp)))) :+: (C1 ('MetaCons "ExceptColumns" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Ref SExp])) :+: (C1 ('MetaCons "SubQuery" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Query)) :+: C1 ('MetaCons "NativeExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NativeExpr))))))

data NativeExpr #

Constructors

PostgresAExpr AExpr
SimpleSQLParserScalarExpr ScalarExpr

Instances

Instances details

Data NativeExpr #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NativeExpr -> c NativeExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NativeExpr # toConstr :: NativeExpr -> Constr # dataTypeOf :: NativeExpr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NativeExpr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NativeExpr) # gmapT :: (forall b. Data b => b -> b) -> NativeExpr -> NativeExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NativeExpr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NativeExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> NativeExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NativeExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NativeExpr -> m NativeExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NativeExpr -> m NativeExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NativeExpr -> m NativeExpr #
Generic NativeExpr #
Instance details Defined in Napkin.Types.Core Associated Types type Rep NativeExpr :: Type -> Type # Methods from :: NativeExpr -> Rep NativeExpr x # to :: Rep NativeExpr x -> NativeExpr #
Show NativeExpr #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> NativeExpr -> ShowS # show :: NativeExpr -> String # showList :: [NativeExpr] -> ShowS #
NFData NativeExpr #
Instance details Defined in Napkin.Types.Core Methods rnf :: NativeExpr -> () #
Eq NativeExpr #
Instance details Defined in Napkin.Types.Core Methods (==) :: NativeExpr -> NativeExpr -> Bool # (/=) :: NativeExpr -> NativeExpr -> Bool #
Ord NativeExpr #
Instance details Defined in Napkin.Types.Core Methods compare :: NativeExpr -> NativeExpr -> Ordering # (<) :: NativeExpr -> NativeExpr -> Bool # (<=) :: NativeExpr -> NativeExpr -> Bool # (>) :: NativeExpr -> NativeExpr -> Bool # (>=) :: NativeExpr -> NativeExpr -> Bool # max :: NativeExpr -> NativeExpr -> NativeExpr # min :: NativeExpr -> NativeExpr -> NativeExpr #
ToDbBackend anyBackend => RenderSql NativeExpr anyBackend #
Instance details Defined in Napkin.Render.Native Methods renderSql :: anyBackend -> NativeExpr -> Doc #
Lift NativeExpr #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => NativeExpr -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => NativeExpr -> Code m NativeExpr #
type Rep NativeExpr #
Instance details Defined in Napkin.Types.Core type Rep NativeExpr = D1 ('MetaData "NativeExpr" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "PostgresAExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AExpr)) :+: C1 ('MetaCons "SimpleSQLParserScalarExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ScalarExpr)))

var :: Ref a -> SExp #

varString :: String -> SExp #

nil :: SExp #

data NullStrategy #

Constructors

IgnoreNulls
RespectNulls

Instances

Instances details

Data NullStrategy #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NullStrategy -> c NullStrategy # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NullStrategy # toConstr :: NullStrategy -> Constr # dataTypeOf :: NullStrategy -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NullStrategy) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullStrategy) # gmapT :: (forall b. Data b => b -> b) -> NullStrategy -> NullStrategy # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NullStrategy -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NullStrategy -> r # gmapQ :: (forall d. Data d => d -> u) -> NullStrategy -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NullStrategy -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NullStrategy -> m NullStrategy # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NullStrategy -> m NullStrategy # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NullStrategy -> m NullStrategy #
Generic NullStrategy #
Instance details Defined in Napkin.Types.Core Associated Types type Rep NullStrategy :: Type -> Type # Methods from :: NullStrategy -> Rep NullStrategy x # to :: Rep NullStrategy x -> NullStrategy #
Show NullStrategy #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> NullStrategy -> ShowS # show :: NullStrategy -> String # showList :: [NullStrategy] -> ShowS #
NFData NullStrategy #
Instance details Defined in Napkin.Types.Core Methods rnf :: NullStrategy -> () #
Eq NullStrategy #
Instance details Defined in Napkin.Types.Core Methods (==) :: NullStrategy -> NullStrategy -> Bool # (/=) :: NullStrategy -> NullStrategy -> Bool #
Ord NullStrategy #
Instance details Defined in Napkin.Types.Core Methods compare :: NullStrategy -> NullStrategy -> Ordering # (<) :: NullStrategy -> NullStrategy -> Bool # (<=) :: NullStrategy -> NullStrategy -> Bool # (>) :: NullStrategy -> NullStrategy -> Bool # (>=) :: NullStrategy -> NullStrategy -> Bool # max :: NullStrategy -> NullStrategy -> NullStrategy # min :: NullStrategy -> NullStrategy -> NullStrategy #
CombiBomb NullStrategy #
Instance details Defined in Napkin.Backends.MsSql.ApiGen.Types Methods toParensOperatorArgs :: NullStrategy -> [ParensOperatorArgument] #
Lift NullStrategy #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => NullStrategy -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => NullStrategy -> Code m NullStrategy #
type Rep NullStrategy #
Instance details Defined in Napkin.Types.Core type Rep NullStrategy = D1 ('MetaData "NullStrategy" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "IgnoreNulls" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RespectNulls" 'PrefixI 'False) (U1 :: Type -> Type))

data Distinctness #

Constructors

Distinct
NonDistinct

Instances

Instances details

Data Distinctness #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Distinctness -> c Distinctness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Distinctness # toConstr :: Distinctness -> Constr # dataTypeOf :: Distinctness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Distinctness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Distinctness) # gmapT :: (forall b. Data b => b -> b) -> Distinctness -> Distinctness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Distinctness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Distinctness -> r # gmapQ :: (forall d. Data d => d -> u) -> Distinctness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Distinctness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Distinctness -> m Distinctness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Distinctness -> m Distinctness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Distinctness -> m Distinctness #
Generic Distinctness #
Instance details Defined in Napkin.Types.Core Associated Types type Rep Distinctness :: Type -> Type # Methods from :: Distinctness -> Rep Distinctness x # to :: Rep Distinctness x -> Distinctness #
Show Distinctness #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Distinctness -> ShowS # show :: Distinctness -> String # showList :: [Distinctness] -> ShowS #
Default Distinctness #
Instance details Defined in Napkin.Types.Core Methods def :: Distinctness #
NFData Distinctness #
Instance details Defined in Napkin.Types.Core Methods rnf :: Distinctness -> () #
Eq Distinctness #
Instance details Defined in Napkin.Types.Core Methods (==) :: Distinctness -> Distinctness -> Bool # (/=) :: Distinctness -> Distinctness -> Bool #
Ord Distinctness #
Instance details Defined in Napkin.Types.Core Methods compare :: Distinctness -> Distinctness -> Ordering # (<) :: Distinctness -> Distinctness -> Bool # (<=) :: Distinctness -> Distinctness -> Bool # (>) :: Distinctness -> Distinctness -> Bool # (>=) :: Distinctness -> Distinctness -> Bool # max :: Distinctness -> Distinctness -> Distinctness # min :: Distinctness -> Distinctness -> Distinctness #
CombiBomb Distinctness #
Instance details Defined in Napkin.Backends.MsSql.ApiGen.Types Methods toParensOperatorArgs :: Distinctness -> [ParensOperatorArgument] #
Lift Distinctness #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Distinctness -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Distinctness -> Code m Distinctness #
type Rep Distinctness #
Instance details Defined in Napkin.Types.Core type Rep Distinctness = D1 ('MetaData "Distinctness" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "Distinct" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NonDistinct" 'PrefixI 'False) (U1 :: Type -> Type))

type Partition = [SExp] #

data WOver #

Constructors

WOver
Fields _overPartition :: Partition _overOrder :: Order _overFrame :: Maybe WindowFrame

Instances

Instances details

Data WOver #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WOver -> c WOver # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WOver # toConstr :: WOver -> Constr # dataTypeOf :: WOver -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WOver) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WOver) # gmapT :: (forall b. Data b => b -> b) -> WOver -> WOver # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WOver -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WOver -> r # gmapQ :: (forall d. Data d => d -> u) -> WOver -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WOver -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WOver -> m WOver # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WOver -> m WOver # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WOver -> m WOver #
Generic WOver #
Instance details Defined in Napkin.Types.Core Associated Types type Rep WOver :: Type -> Type # Methods from :: WOver -> Rep WOver x # to :: Rep WOver x -> WOver #
Show WOver #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> WOver -> ShowS # show :: WOver -> String # showList :: [WOver] -> ShowS #
Default WOver #
Instance details Defined in Napkin.Types.Core Methods def :: WOver #
NFData WOver #
Instance details Defined in Napkin.Types.Core Methods rnf :: WOver -> () #
Eq WOver #
Instance details Defined in Napkin.Types.Core Methods (==) :: WOver -> WOver -> Bool # (/=) :: WOver -> WOver -> Bool #
Ord WOver #
Instance details Defined in Napkin.Types.Core Methods compare :: WOver -> WOver -> Ordering # (<) :: WOver -> WOver -> Bool # (<=) :: WOver -> WOver -> Bool # (>) :: WOver -> WOver -> Bool # (>=) :: WOver -> WOver -> Bool # max :: WOver -> WOver -> WOver # min :: WOver -> WOver -> WOver #
Lift WOver #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => WOver -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => WOver -> Code m WOver #
type Rep WOver #
Instance details Defined in Napkin.Types.Core type Rep WOver = D1 ('MetaData "WOver" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "WOver" 'PrefixI 'True) (S1 ('MetaSel ('Just "_overPartition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Partition) :: (S1 ('MetaSel ('Just "_overOrder") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Order) :: S1 ('MetaSel ('Just "_overFrame") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe WindowFrame)))))

data WindowFrameUnit #

Constructors

WindowRows
WindowRange

Instances

Instances details

Data WindowFrameUnit #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WindowFrameUnit -> c WindowFrameUnit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WindowFrameUnit # toConstr :: WindowFrameUnit -> Constr # dataTypeOf :: WindowFrameUnit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WindowFrameUnit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WindowFrameUnit) # gmapT :: (forall b. Data b => b -> b) -> WindowFrameUnit -> WindowFrameUnit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WindowFrameUnit -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WindowFrameUnit -> r # gmapQ :: (forall d. Data d => d -> u) -> WindowFrameUnit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WindowFrameUnit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WindowFrameUnit -> m WindowFrameUnit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WindowFrameUnit -> m WindowFrameUnit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WindowFrameUnit -> m WindowFrameUnit #
Generic WindowFrameUnit #
Instance details Defined in Napkin.Types.Core Associated Types type Rep WindowFrameUnit :: Type -> Type # Methods from :: WindowFrameUnit -> Rep WindowFrameUnit x # to :: Rep WindowFrameUnit x -> WindowFrameUnit #
Show WindowFrameUnit #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> WindowFrameUnit -> ShowS # show :: WindowFrameUnit -> String # showList :: [WindowFrameUnit] -> ShowS #
NFData WindowFrameUnit #
Instance details Defined in Napkin.Types.Core Methods rnf :: WindowFrameUnit -> () #
Eq WindowFrameUnit #
Instance details Defined in Napkin.Types.Core Methods (==) :: WindowFrameUnit -> WindowFrameUnit -> Bool # (/=) :: WindowFrameUnit -> WindowFrameUnit -> Bool #
Ord WindowFrameUnit #
Instance details Defined in Napkin.Types.Core Methods compare :: WindowFrameUnit -> WindowFrameUnit -> Ordering # (<) :: WindowFrameUnit -> WindowFrameUnit -> Bool # (<=) :: WindowFrameUnit -> WindowFrameUnit -> Bool # (>) :: WindowFrameUnit -> WindowFrameUnit -> Bool # (>=) :: WindowFrameUnit -> WindowFrameUnit -> Bool # max :: WindowFrameUnit -> WindowFrameUnit -> WindowFrameUnit # min :: WindowFrameUnit -> WindowFrameUnit -> WindowFrameUnit #
Lift WindowFrameUnit #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => WindowFrameUnit -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => WindowFrameUnit -> Code m WindowFrameUnit #
type Rep WindowFrameUnit #
Instance details Defined in Napkin.Types.Core type Rep WindowFrameUnit = D1 ('MetaData "WindowFrameUnit" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "WindowRows" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WindowRange" 'PrefixI 'False) (U1 :: Type -> Type))

data WindowFun #

Constructors

SimpleWindow (Ref Function) [SExp] WOver (Maybe NullStrategy)

Instances

Instances details

Data WindowFun #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WindowFun -> c WindowFun # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WindowFun # toConstr :: WindowFun -> Constr # dataTypeOf :: WindowFun -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WindowFun) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WindowFun) # gmapT :: (forall b. Data b => b -> b) -> WindowFun -> WindowFun # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WindowFun -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WindowFun -> r # gmapQ :: (forall d. Data d => d -> u) -> WindowFun -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WindowFun -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WindowFun -> m WindowFun # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WindowFun -> m WindowFun # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WindowFun -> m WindowFun #
Generic WindowFun #
Instance details Defined in Napkin.Types.Core Associated Types type Rep WindowFun :: Type -> Type # Methods from :: WindowFun -> Rep WindowFun x # to :: Rep WindowFun x -> WindowFun #
Show WindowFun #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> WindowFun -> ShowS # show :: WindowFun -> String # showList :: [WindowFun] -> ShowS #
NFData WindowFun #
Instance details Defined in Napkin.Types.Core Methods rnf :: WindowFun -> () #
Eq WindowFun #
Instance details Defined in Napkin.Types.Core Methods (==) :: WindowFun -> WindowFun -> Bool # (/=) :: WindowFun -> WindowFun -> Bool #
Ord WindowFun #
Instance details Defined in Napkin.Types.Core Methods compare :: WindowFun -> WindowFun -> Ordering # (<) :: WindowFun -> WindowFun -> Bool # (<=) :: WindowFun -> WindowFun -> Bool # (>) :: WindowFun -> WindowFun -> Bool # (>=) :: WindowFun -> WindowFun -> Bool # max :: WindowFun -> WindowFun -> WindowFun # min :: WindowFun -> WindowFun -> WindowFun #
HasDeps WindowFun #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: WindowFun -> Set (Ref Table) # traverseDependencies :: Fold WindowFun (Ref Table) #
FunRenamer WindowFun #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> WindowFun -> WindowFun #
TableRenamer WindowFun #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> WindowFun -> WindowFun #
Lift WindowFun #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => WindowFun -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => WindowFun -> Code m WindowFun #
type Rep WindowFun #
Instance details Defined in Napkin.Types.Core type Rep WindowFun = D1 ('MetaData "WindowFun" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "SimpleWindow" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Ref Function)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [SExp])) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 WOver) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe NullStrategy)))))

data WindowFrame #

Constructors

WindowBetween WindowFrameUnit FrameLength FrameLength
WindowFrom WindowFrameUnit FrameLength

Instances

Instances details

Data WindowFrame #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WindowFrame -> c WindowFrame # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WindowFrame # toConstr :: WindowFrame -> Constr # dataTypeOf :: WindowFrame -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WindowFrame) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WindowFrame) # gmapT :: (forall b. Data b => b -> b) -> WindowFrame -> WindowFrame # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WindowFrame -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WindowFrame -> r # gmapQ :: (forall d. Data d => d -> u) -> WindowFrame -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WindowFrame -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WindowFrame -> m WindowFrame # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WindowFrame -> m WindowFrame # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WindowFrame -> m WindowFrame #
Generic WindowFrame #
Instance details Defined in Napkin.Types.Core Associated Types type Rep WindowFrame :: Type -> Type # Methods from :: WindowFrame -> Rep WindowFrame x # to :: Rep WindowFrame x -> WindowFrame #
Show WindowFrame #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> WindowFrame -> ShowS # show :: WindowFrame -> String # showList :: [WindowFrame] -> ShowS #
NFData WindowFrame #
Instance details Defined in Napkin.Types.Core Methods rnf :: WindowFrame -> () #
Eq WindowFrame #
Instance details Defined in Napkin.Types.Core Methods (==) :: WindowFrame -> WindowFrame -> Bool # (/=) :: WindowFrame -> WindowFrame -> Bool #
Ord WindowFrame #
Instance details Defined in Napkin.Types.Core Methods compare :: WindowFrame -> WindowFrame -> Ordering # (<) :: WindowFrame -> WindowFrame -> Bool # (<=) :: WindowFrame -> WindowFrame -> Bool # (>) :: WindowFrame -> WindowFrame -> Bool # (>=) :: WindowFrame -> WindowFrame -> Bool # max :: WindowFrame -> WindowFrame -> WindowFrame # min :: WindowFrame -> WindowFrame -> WindowFrame #
Lift WindowFrame #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => WindowFrame -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => WindowFrame -> Code m WindowFrame #
type Rep WindowFrame #
Instance details Defined in Napkin.Types.Core type Rep WindowFrame = D1 ('MetaData "WindowFrame" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "WindowBetween" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 WindowFrameUnit) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FrameLength) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FrameLength))) :+: C1 ('MetaCons "WindowFrom" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 WindowFrameUnit) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FrameLength)))

data FrameLength #

Constructors

CurrentRow
Unbounded
LimitedPreceding SExp
LimitedFollowing SExp

Instances

Instances details

Data FrameLength #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FrameLength -> c FrameLength # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FrameLength # toConstr :: FrameLength -> Constr # dataTypeOf :: FrameLength -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FrameLength) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameLength) # gmapT :: (forall b. Data b => b -> b) -> FrameLength -> FrameLength # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FrameLength -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FrameLength -> r # gmapQ :: (forall d. Data d => d -> u) -> FrameLength -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FrameLength -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FrameLength -> m FrameLength # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FrameLength -> m FrameLength # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FrameLength -> m FrameLength #
Generic FrameLength #
Instance details Defined in Napkin.Types.Core Associated Types type Rep FrameLength :: Type -> Type # Methods from :: FrameLength -> Rep FrameLength x # to :: Rep FrameLength x -> FrameLength #
Show FrameLength #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> FrameLength -> ShowS # show :: FrameLength -> String # showList :: [FrameLength] -> ShowS #
NFData FrameLength #
Instance details Defined in Napkin.Types.Core Methods rnf :: FrameLength -> () #
Eq FrameLength #
Instance details Defined in Napkin.Types.Core Methods (==) :: FrameLength -> FrameLength -> Bool # (/=) :: FrameLength -> FrameLength -> Bool #
Ord FrameLength #
Instance details Defined in Napkin.Types.Core Methods compare :: FrameLength -> FrameLength -> Ordering # (<) :: FrameLength -> FrameLength -> Bool # (<=) :: FrameLength -> FrameLength -> Bool # (>) :: FrameLength -> FrameLength -> Bool # (>=) :: FrameLength -> FrameLength -> Bool # max :: FrameLength -> FrameLength -> FrameLength # min :: FrameLength -> FrameLength -> FrameLength #
Lift FrameLength #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => FrameLength -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => FrameLength -> Code m FrameLength #
type Rep FrameLength #
Instance details Defined in Napkin.Types.Core type Rep FrameLength = D1 ('MetaData "FrameLength" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) ((C1 ('MetaCons "CurrentRow" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Unbounded" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LimitedPreceding" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp)) :+: C1 ('MetaCons "LimitedFollowing" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp))))

data FunModifier #

Constructors

ModDistinct Distinctness
ModNulls NullStrategy
ModOrder Order
ModLimit Int
ModOver WOver

Instances

Instances details

Data FunModifier #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunModifier -> c FunModifier # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunModifier # toConstr :: FunModifier -> Constr # dataTypeOf :: FunModifier -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunModifier) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunModifier) # gmapT :: (forall b. Data b => b -> b) -> FunModifier -> FunModifier # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunModifier -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunModifier -> r # gmapQ :: (forall d. Data d => d -> u) -> FunModifier -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunModifier -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunModifier -> m FunModifier # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunModifier -> m FunModifier # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunModifier -> m FunModifier #
Generic FunModifier #
Instance details Defined in Napkin.Types.Core Associated Types type Rep FunModifier :: Type -> Type # Methods from :: FunModifier -> Rep FunModifier x # to :: Rep FunModifier x -> FunModifier #
Show FunModifier #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> FunModifier -> ShowS # show :: FunModifier -> String # showList :: [FunModifier] -> ShowS #
NFData FunModifier #
Instance details Defined in Napkin.Types.Core Methods rnf :: FunModifier -> () #
Eq FunModifier #
Instance details Defined in Napkin.Types.Core Methods (==) :: FunModifier -> FunModifier -> Bool # (/=) :: FunModifier -> FunModifier -> Bool #
Ord FunModifier #
Instance details Defined in Napkin.Types.Core Methods compare :: FunModifier -> FunModifier -> Ordering # (<) :: FunModifier -> FunModifier -> Bool # (<=) :: FunModifier -> FunModifier -> Bool # (>) :: FunModifier -> FunModifier -> Bool # (>=) :: FunModifier -> FunModifier -> Bool # max :: FunModifier -> FunModifier -> FunModifier # min :: FunModifier -> FunModifier -> FunModifier #
Lift FunModifier #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => FunModifier -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => FunModifier -> Code m FunModifier #
type Rep FunModifier #
Instance details Defined in Napkin.Types.Core type Rep FunModifier = D1 ('MetaData "FunModifier" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) ((C1 ('MetaCons "ModDistinct" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Distinctness)) :+: C1 ('MetaCons "ModNulls" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NullStrategy))) :+: (C1 ('MetaCons "ModOrder" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Order)) :+: (C1 ('MetaCons "ModLimit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: C1 ('MetaCons "ModOver" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 WOver)))))

data ExternFun #

Constructors

SimpleExtern (Ref Function) [SExp]
ParensExtern [ParensOperator]
ModExtern (Ref Function) [SExp] [FunModifier]
Cast SExp Type
SafeCast SExp Type
ExternWindow WindowFun
ExternRaw String

Instances

Instances details

Data ExternFun #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExternFun -> c ExternFun # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ExternFun # toConstr :: ExternFun -> Constr # dataTypeOf :: ExternFun -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ExternFun) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExternFun) # gmapT :: (forall b. Data b => b -> b) -> ExternFun -> ExternFun # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExternFun -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExternFun -> r # gmapQ :: (forall d. Data d => d -> u) -> ExternFun -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ExternFun -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExternFun -> m ExternFun # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExternFun -> m ExternFun # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExternFun -> m ExternFun #
Generic ExternFun #
Instance details Defined in Napkin.Types.Core Associated Types type Rep ExternFun :: Type -> Type # Methods from :: ExternFun -> Rep ExternFun x # to :: Rep ExternFun x -> ExternFun #
Show ExternFun #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> ExternFun -> ShowS # show :: ExternFun -> String # showList :: [ExternFun] -> ShowS #
NFData ExternFun #
Instance details Defined in Napkin.Types.Core Methods rnf :: ExternFun -> () #
Eq ExternFun #
Instance details Defined in Napkin.Types.Core Methods (==) :: ExternFun -> ExternFun -> Bool # (/=) :: ExternFun -> ExternFun -> Bool #
Ord ExternFun #
Instance details Defined in Napkin.Types.Core Methods compare :: ExternFun -> ExternFun -> Ordering # (<) :: ExternFun -> ExternFun -> Bool # (<=) :: ExternFun -> ExternFun -> Bool # (>) :: ExternFun -> ExternFun -> Bool # (>=) :: ExternFun -> ExternFun -> Bool # max :: ExternFun -> ExternFun -> ExternFun # min :: ExternFun -> ExternFun -> ExternFun #
HasDeps ExternFun #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: ExternFun -> Set (Ref Table) # traverseDependencies :: Fold ExternFun (Ref Table) #
FunRenamer ExternFun #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> ExternFun -> ExternFun #
TableRenamer ExternFun #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> ExternFun -> ExternFun #
RenderSql ExternFun Postgres #
Instance details Defined in Napkin.Render.Postgres Methods renderSql :: Postgres -> ExternFun -> Doc #
RenderSql ExternFun Redshift #
Instance details Defined in Napkin.Render.Redshift Methods renderSql :: Redshift -> ExternFun -> Doc #
Lift ExternFun #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => ExternFun -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ExternFun -> Code m ExternFun #
type Rep ExternFun #
Instance details Defined in Napkin.Types.Core type Rep ExternFun = D1 ('MetaData "ExternFun" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) ((C1 ('MetaCons "SimpleExtern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Ref Function)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [SExp])) :+: (C1 ('MetaCons "ParensExtern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ParensOperator])) :+: C1 ('MetaCons "ModExtern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Ref Function)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [SExp]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FunModifier]))))) :+: ((C1 ('MetaCons "Cast" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)) :+: C1 ('MetaCons "SafeCast" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) :+: (C1 ('MetaCons "ExternWindow" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 WindowFun)) :+: C1 ('MetaCons "ExternRaw" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))))

type OriginTypeName = Text #

data Type #

Instances

Instances details

Data Type #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type # toConstr :: Type -> Constr # dataTypeOf :: Type -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) # gmapT :: (forall b. Data b => b -> b) -> Type -> Type # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #
Generic Type #
Instance details Defined in Napkin.Types.Core Associated Types type Rep Type :: Type -> Type # Methods from :: Type -> Rep Type x # to :: Rep Type x -> Type #
Show Type #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Type -> ShowS # show :: Type -> String # showList :: [Type] -> ShowS #
NFData Type #
Instance details Defined in Napkin.Types.Core Methods rnf :: Type -> () #
Eq Type #
Instance details Defined in Napkin.Types.Core Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Ord Type #
Instance details Defined in Napkin.Types.Core Methods compare :: Type -> Type -> Ordering # (<) :: Type -> Type -> Bool # (<=) :: Type -> Type -> Bool # (>) :: Type -> Type -> Bool # (>=) :: Type -> Type -> Bool # max :: Type -> Type -> Type # min :: Type -> Type -> Type #
Lift Type #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Type -> m Exp # liftTyped :: forall (m :: Type0 -> Type0). Quote m => Type -> Code m Type #
type Rep Type #
Instance details Defined in Napkin.Types.Core type Rep Type = D1 ('MetaData "Type" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) ((((C1 ('MetaCons "TySmallInt" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TyInteger" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TyBigInt" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TyDecimal" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TyReal" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "TyDouble" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TyBool" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TyChar" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TyVarChar" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TyBlob" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "TyUnknown" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 OriginTypeName)) :+: C1 ('MetaCons "TyVarCharWithLen" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))) :+: (C1 ('MetaCons "TyDate" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TyTimestamp" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TyDatetime" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "TyInterval" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TyLimited" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))) :+: (C1 ('MetaCons "Ty2DLimited" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))) :+: (C1 ('MetaCons "TyArray" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Int))) :+: C1 ('MetaCons "TyStruct" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (OMap StructField Type))))))))

data DatePart #

Constructors

Millennium
Century
Decade
Epoch
Year
Quarter
Month
Week
DayOfWeek
DayOfYear
Day
Hour
Minute
Second
Millisecond
Microsecond

Instances

Instances details

Data DatePart #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DatePart -> c DatePart # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DatePart # toConstr :: DatePart -> Constr # dataTypeOf :: DatePart -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DatePart) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DatePart) # gmapT :: (forall b. Data b => b -> b) -> DatePart -> DatePart # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DatePart -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DatePart -> r # gmapQ :: (forall d. Data d => d -> u) -> DatePart -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DatePart -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DatePart -> m DatePart # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DatePart -> m DatePart # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DatePart -> m DatePart #
Generic DatePart #
Instance details Defined in Napkin.Types.Core Associated Types type Rep DatePart :: Type -> Type # Methods from :: DatePart -> Rep DatePart x # to :: Rep DatePart x -> DatePart #
Show DatePart #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> DatePart -> ShowS # show :: DatePart -> String # showList :: [DatePart] -> ShowS #
NFData DatePart #
Instance details Defined in Napkin.Types.Core Methods rnf :: DatePart -> () #
Eq DatePart #
Instance details Defined in Napkin.Types.Core Methods (==) :: DatePart -> DatePart -> Bool # (/=) :: DatePart -> DatePart -> Bool #
Ord DatePart #
Instance details Defined in Napkin.Types.Core Methods compare :: DatePart -> DatePart -> Ordering # (<) :: DatePart -> DatePart -> Bool # (<=) :: DatePart -> DatePart -> Bool # (>) :: DatePart -> DatePart -> Bool # (>=) :: DatePart -> DatePart -> Bool # max :: DatePart -> DatePart -> DatePart # min :: DatePart -> DatePart -> DatePart #
Val DatePart #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value DatePart #
Lift DatePart #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => DatePart -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => DatePart -> Code m DatePart #
type Rep DatePart #
Instance details Defined in Napkin.Types.Core type Rep DatePart = D1 ('MetaData "DatePart" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) ((((C1 ('MetaCons "Millennium" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Century" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Decade" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Epoch" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Year" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Quarter" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Month" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Week" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "DayOfWeek" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DayOfYear" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Day" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Hour" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Minute" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Second" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Millisecond" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Microsecond" 'PrefixI 'False) (U1 :: Type -> Type)))))

type Order = [OrderPart] #

type GroupBy = [SExp] #

data OrderDir #

Constructors

Asc
Desc

Instances

Instances details

Data OrderDir #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OrderDir -> c OrderDir # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OrderDir # toConstr :: OrderDir -> Constr # dataTypeOf :: OrderDir -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OrderDir) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OrderDir) # gmapT :: (forall b. Data b => b -> b) -> OrderDir -> OrderDir # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OrderDir -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OrderDir -> r # gmapQ :: (forall d. Data d => d -> u) -> OrderDir -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OrderDir -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OrderDir -> m OrderDir # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderDir -> m OrderDir # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderDir -> m OrderDir #
Generic OrderDir #
Instance details Defined in Napkin.Types.Core Associated Types type Rep OrderDir :: Type -> Type # Methods from :: OrderDir -> Rep OrderDir x # to :: Rep OrderDir x -> OrderDir #
Show OrderDir #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> OrderDir -> ShowS # show :: OrderDir -> String # showList :: [OrderDir] -> ShowS #
NFData OrderDir #
Instance details Defined in Napkin.Types.Core Methods rnf :: OrderDir -> () #
Eq OrderDir #
Instance details Defined in Napkin.Types.Core Methods (==) :: OrderDir -> OrderDir -> Bool # (/=) :: OrderDir -> OrderDir -> Bool #
Ord OrderDir #
Instance details Defined in Napkin.Types.Core Methods compare :: OrderDir -> OrderDir -> Ordering # (<) :: OrderDir -> OrderDir -> Bool # (<=) :: OrderDir -> OrderDir -> Bool # (>) :: OrderDir -> OrderDir -> Bool # (>=) :: OrderDir -> OrderDir -> Bool # max :: OrderDir -> OrderDir -> OrderDir # min :: OrderDir -> OrderDir -> OrderDir #
CombiBomb OrderDir #
Instance details Defined in Napkin.Backends.MsSql.ApiGen.Types Methods toParensOperatorArgs :: OrderDir -> [ParensOperatorArgument] #
Lift OrderDir #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => OrderDir -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => OrderDir -> Code m OrderDir #
type Rep OrderDir #
Instance details Defined in Napkin.Types.Core type Rep OrderDir = D1 ('MetaData "OrderDir" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "Asc" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Desc" 'PrefixI 'False) (U1 :: Type -> Type))

invertOrder :: OrderDir -> OrderDir #

Flip order

data NullOrder #

Constructors

NullsFirst
NullsLast

Instances

Instances details

Data NullOrder #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NullOrder -> c NullOrder # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NullOrder # toConstr :: NullOrder -> Constr # dataTypeOf :: NullOrder -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NullOrder) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullOrder) # gmapT :: (forall b. Data b => b -> b) -> NullOrder -> NullOrder # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NullOrder -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NullOrder -> r # gmapQ :: (forall d. Data d => d -> u) -> NullOrder -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NullOrder -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NullOrder -> m NullOrder # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NullOrder -> m NullOrder # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NullOrder -> m NullOrder #
Generic NullOrder #
Instance details Defined in Napkin.Types.Core Associated Types type Rep NullOrder :: Type -> Type # Methods from :: NullOrder -> Rep NullOrder x # to :: Rep NullOrder x -> NullOrder #
Show NullOrder #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> NullOrder -> ShowS # show :: NullOrder -> String # showList :: [NullOrder] -> ShowS #
NFData NullOrder #
Instance details Defined in Napkin.Types.Core Methods rnf :: NullOrder -> () #
Eq NullOrder #
Instance details Defined in Napkin.Types.Core Methods (==) :: NullOrder -> NullOrder -> Bool # (/=) :: NullOrder -> NullOrder -> Bool #
Ord NullOrder #
Instance details Defined in Napkin.Types.Core Methods compare :: NullOrder -> NullOrder -> Ordering # (<) :: NullOrder -> NullOrder -> Bool # (<=) :: NullOrder -> NullOrder -> Bool # (>) :: NullOrder -> NullOrder -> Bool # (>=) :: NullOrder -> NullOrder -> Bool # max :: NullOrder -> NullOrder -> NullOrder # min :: NullOrder -> NullOrder -> NullOrder #
Lift NullOrder #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => NullOrder -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => NullOrder -> Code m NullOrder #
type Rep NullOrder #
Instance details Defined in Napkin.Types.Core type Rep NullOrder = D1 ('MetaData "NullOrder" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "NullsFirst" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NullsLast" 'PrefixI 'False) (U1 :: Type -> Type))

data OrderPart #

Constructors

OrderPart
Fields _opExp :: SExp _opOrder :: OrderDir _opNulls :: Maybe NullOrder

Instances

Instances details

Data OrderPart #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OrderPart -> c OrderPart # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OrderPart # toConstr :: OrderPart -> Constr # dataTypeOf :: OrderPart -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OrderPart) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OrderPart) # gmapT :: (forall b. Data b => b -> b) -> OrderPart -> OrderPart # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OrderPart -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OrderPart -> r # gmapQ :: (forall d. Data d => d -> u) -> OrderPart -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OrderPart -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OrderPart -> m OrderPart # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderPart -> m OrderPart # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderPart -> m OrderPart #
Generic OrderPart #
Instance details Defined in Napkin.Types.Core Associated Types type Rep OrderPart :: Type -> Type # Methods from :: OrderPart -> Rep OrderPart x # to :: Rep OrderPart x -> OrderPart #
Show OrderPart #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> OrderPart -> ShowS # show :: OrderPart -> String # showList :: [OrderPart] -> ShowS #
NFData OrderPart #
Instance details Defined in Napkin.Types.Core Methods rnf :: OrderPart -> () #
Eq OrderPart #
Instance details Defined in Napkin.Types.Core Methods (==) :: OrderPart -> OrderPart -> Bool # (/=) :: OrderPart -> OrderPart -> Bool #
Ord OrderPart #
Instance details Defined in Napkin.Types.Core Methods compare :: OrderPart -> OrderPart -> Ordering # (<) :: OrderPart -> OrderPart -> Bool # (<=) :: OrderPart -> OrderPart -> Bool # (>) :: OrderPart -> OrderPart -> Bool # (>=) :: OrderPart -> OrderPart -> Bool # max :: OrderPart -> OrderPart -> OrderPart # min :: OrderPart -> OrderPart -> OrderPart #
FunRenamer OrderPart #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> OrderPart -> OrderPart #
FunctionTransformer OrderPart #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> OrderPart -> OrderPart #
TableRenamer OrderPart #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> OrderPart -> OrderPart #
Lift OrderPart #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => OrderPart -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => OrderPart -> Code m OrderPart #
type Rep OrderPart #
Instance details Defined in Napkin.Types.Core type Rep OrderPart = D1 ('MetaData "OrderPart" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "OrderPart" 'PrefixI 'True) (S1 ('MetaSel ('Just "_opExp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp) :: (S1 ('MetaSel ('Just "_opOrder") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 OrderDir) :: S1 ('MetaSel ('Just "_opNulls") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe NullOrder)))))

order :: SExp -> OrderPart #

data Relation #

Constructors

TableRelation (Ref Table)
QueryRelation Query
ArrayRelation SExp
RawRelation [Ref Table] String	Escape hatch: A raw relation with its dependencies. Avoid if possible

Instances

Instances details

Data Relation #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Relation -> c Relation # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Relation # toConstr :: Relation -> Constr # dataTypeOf :: Relation -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Relation) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Relation) # gmapT :: (forall b. Data b => b -> b) -> Relation -> Relation # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Relation -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Relation -> r # gmapQ :: (forall d. Data d => d -> u) -> Relation -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Relation -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Relation -> m Relation # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Relation -> m Relation # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Relation -> m Relation #
IsString Relation #
Instance details Defined in Napkin.Types.Core Methods fromString :: String -> Relation #
Generic Relation #
Instance details Defined in Napkin.Types.Core Associated Types type Rep Relation :: Type -> Type # Methods from :: Relation -> Rep Relation x # to :: Rep Relation x -> Relation #
Show Relation #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Relation -> ShowS # show :: Relation -> String # showList :: [Relation] -> ShowS #
NFData Relation #
Instance details Defined in Napkin.Types.Core Methods rnf :: Relation -> () #
Eq Relation #
Instance details Defined in Napkin.Types.Core Methods (==) :: Relation -> Relation -> Bool # (/=) :: Relation -> Relation -> Bool #
Ord Relation #
Instance details Defined in Napkin.Types.Core Methods compare :: Relation -> Relation -> Ordering # (<) :: Relation -> Relation -> Bool # (<=) :: Relation -> Relation -> Bool # (>) :: Relation -> Relation -> Bool # (>=) :: Relation -> Relation -> Bool # max :: Relation -> Relation -> Relation # min :: Relation -> Relation -> Relation #
AsRelation Relation #
Instance details Defined in Napkin.Types.Core Methods asRelation :: Relation -> Relation #
MaybeQuery Relation #
Instance details Defined in Napkin.Types.Core Methods getQuery :: Relation -> Maybe Query #
HasDeps Relation #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: Relation -> Set (Ref Table) # traverseDependencies :: Fold Relation (Ref Table) #
FunRenamer Relation #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> Relation -> Relation #
FunctionTransformer Relation #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> Relation -> Relation #
TableRenamer Relation #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Relation -> Relation #
RenderSql Relation BigQuery #
Instance details Defined in Napkin.Render.BigQuery Methods renderSql :: BigQuery -> Relation -> Doc #
RenderSql Relation MsSql #
Instance details Defined in Napkin.Render.MsSql Methods renderSql :: MsSql -> Relation -> Doc #
RenderSql Relation Postgres #
Instance details Defined in Napkin.Render.Postgres Methods renderSql :: Postgres -> Relation -> Doc #
RenderSql Relation Redshift #
Instance details Defined in Napkin.Render.Redshift Methods renderSql :: Redshift -> Relation -> Doc #
RenderSql Relation Sqlite #
Instance details Defined in Napkin.Render.Sqlite Methods renderSql :: Sqlite -> Relation -> Doc #
Lift Relation #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Relation -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Relation -> Code m Relation #
FunRenamer (Selected Relation) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> Selected Relation -> Selected Relation #
FunctionTransformer (Selected Relation) #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> Selected Relation -> Selected Relation #
TableRenamer (Selected Relation) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Selected Relation -> Selected Relation #
type Rep Relation #
Instance details Defined in Napkin.Types.Core type Rep Relation = D1 ('MetaData "Relation" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) ((C1 ('MetaCons "TableRelation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Ref Table))) :+: C1 ('MetaCons "QueryRelation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Query))) :+: (C1 ('MetaCons "ArrayRelation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SExp)) :+: C1 ('MetaCons "RawRelation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Ref Table]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))))

table :: Ref a -> Relation #

treat a reference as relation

data JoinType #

Constructors

JoinLeft
JoinRight
JoinInner
JoinCross
JoinOuter

Instances

Instances details

Data JoinType #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinType -> c JoinType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinType # toConstr :: JoinType -> Constr # dataTypeOf :: JoinType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JoinType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType) # gmapT :: (forall b. Data b => b -> b) -> JoinType -> JoinType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r # gmapQ :: (forall d. Data d => d -> u) -> JoinType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType #
Generic JoinType #
Instance details Defined in Napkin.Types.Core Associated Types type Rep JoinType :: Type -> Type # Methods from :: JoinType -> Rep JoinType x # to :: Rep JoinType x -> JoinType #
Show JoinType #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> JoinType -> ShowS # show :: JoinType -> String # showList :: [JoinType] -> ShowS #
NFData JoinType #
Instance details Defined in Napkin.Types.Core Methods rnf :: JoinType -> () #
Eq JoinType #
Instance details Defined in Napkin.Types.Core Methods (==) :: JoinType -> JoinType -> Bool # (/=) :: JoinType -> JoinType -> Bool #
Ord JoinType #
Instance details Defined in Napkin.Types.Core Methods compare :: JoinType -> JoinType -> Ordering # (<) :: JoinType -> JoinType -> Bool # (<=) :: JoinType -> JoinType -> Bool # (>) :: JoinType -> JoinType -> Bool # (>=) :: JoinType -> JoinType -> Bool # max :: JoinType -> JoinType -> JoinType # min :: JoinType -> JoinType -> JoinType #
Lift JoinType #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => JoinType -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => JoinType -> Code m JoinType #
type Rep JoinType #
Instance details Defined in Napkin.Types.Core type Rep JoinType = D1 ('MetaData "JoinType" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) ((C1 ('MetaCons "JoinLeft" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "JoinRight" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "JoinInner" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "JoinCross" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "JoinOuter" 'PrefixI 'False) (U1 :: Type -> Type))))

data From #

Constructors

From (Selected Relation) [(Selected Relation, JoinType, Either (Maybe SExp) [Ref SExp])]

Instances

Instances details

Data From #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> From -> c From # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c From # toConstr :: From -> Constr # dataTypeOf :: From -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c From) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c From) # gmapT :: (forall b. Data b => b -> b) -> From -> From # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> From -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> From -> r # gmapQ :: (forall d. Data d => d -> u) -> From -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> From -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> From -> m From # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> From -> m From # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> From -> m From #
Generic From #
Instance details Defined in Napkin.Types.Core Associated Types type Rep From :: Type -> Type # Methods from :: From -> Rep From x # to :: Rep From x -> From #
Show From #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> From -> ShowS # show :: From -> String # showList :: [From] -> ShowS #
NFData From #
Instance details Defined in Napkin.Types.Core Methods rnf :: From -> () #
Eq From #
Instance details Defined in Napkin.Types.Core Methods (==) :: From -> From -> Bool # (/=) :: From -> From -> Bool #
Ord From #
Instance details Defined in Napkin.Types.Core Methods compare :: From -> From -> Ordering # (<) :: From -> From -> Bool # (<=) :: From -> From -> Bool # (>) :: From -> From -> Bool # (>=) :: From -> From -> Bool # max :: From -> From -> From # min :: From -> From -> From #
HasDeps From #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: From -> Set (Ref Table) # traverseDependencies :: Fold From (Ref Table) #
FunRenamer From #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> From -> From #
FunctionTransformer From #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> From -> From #
TableRenamer From #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> From -> From #
RenderSql From BigQuery #
Instance details Defined in Napkin.Render.BigQuery Methods renderSql :: BigQuery -> From -> Doc #
RenderSql From MsSql #
Instance details Defined in Napkin.Render.MsSql Methods renderSql :: MsSql -> From -> Doc #
RenderSql From Postgres #
Instance details Defined in Napkin.Render.Postgres Methods renderSql :: Postgres -> From -> Doc #
RenderSql From Redshift #
Instance details Defined in Napkin.Render.Redshift Methods renderSql :: Redshift -> From -> Doc #
RenderSql From Sqlite #
Instance details Defined in Napkin.Render.Sqlite Methods renderSql :: Sqlite -> From -> Doc #
Lift From #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => From -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => From -> Code m From #
type Rep From #
Instance details Defined in Napkin.Types.Core type Rep From = D1 ('MetaData "From" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "From" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Selected Relation)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Selected Relation, JoinType, Either (Maybe SExp) [Ref SExp])])))

fromAliases :: From -> [Ref Relation] #

data UnionType #

Constructors

SetUnion
DuplicateUnion
IntersectUnion
MinusUnion

Instances

Instances details

Data UnionType #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnionType -> c UnionType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnionType # toConstr :: UnionType -> Constr # dataTypeOf :: UnionType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnionType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnionType) # gmapT :: (forall b. Data b => b -> b) -> UnionType -> UnionType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnionType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnionType -> r # gmapQ :: (forall d. Data d => d -> u) -> UnionType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UnionType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnionType -> m UnionType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnionType -> m UnionType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnionType -> m UnionType #
Generic UnionType #
Instance details Defined in Napkin.Types.Core Associated Types type Rep UnionType :: Type -> Type # Methods from :: UnionType -> Rep UnionType x # to :: Rep UnionType x -> UnionType #
Show UnionType #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> UnionType -> ShowS # show :: UnionType -> String # showList :: [UnionType] -> ShowS #
NFData UnionType #
Instance details Defined in Napkin.Types.Core Methods rnf :: UnionType -> () #
Eq UnionType #
Instance details Defined in Napkin.Types.Core Methods (==) :: UnionType -> UnionType -> Bool # (/=) :: UnionType -> UnionType -> Bool #
Ord UnionType #
Instance details Defined in Napkin.Types.Core Methods compare :: UnionType -> UnionType -> Ordering # (<) :: UnionType -> UnionType -> Bool # (<=) :: UnionType -> UnionType -> Bool # (>) :: UnionType -> UnionType -> Bool # (>=) :: UnionType -> UnionType -> Bool # max :: UnionType -> UnionType -> UnionType # min :: UnionType -> UnionType -> UnionType #
Lift UnionType #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => UnionType -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => UnionType -> Code m UnionType #
type Rep UnionType #
Instance details Defined in Napkin.Types.Core type Rep UnionType = D1 ('MetaData "UnionType" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) ((C1 ('MetaCons "SetUnion" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DuplicateUnion" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "IntersectUnion" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MinusUnion" 'PrefixI 'False) (U1 :: Type -> Type)))

data RawQuery #

Constructors

RawQuery
Fields _rawQuery_deps :: [Ref Table] _rawQuery_raw :: String

Instances

Instances details

Data RawQuery #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RawQuery -> c RawQuery # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RawQuery # toConstr :: RawQuery -> Constr # dataTypeOf :: RawQuery -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RawQuery) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RawQuery) # gmapT :: (forall b. Data b => b -> b) -> RawQuery -> RawQuery # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RawQuery -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RawQuery -> r # gmapQ :: (forall d. Data d => d -> u) -> RawQuery -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RawQuery -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RawQuery -> m RawQuery # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RawQuery -> m RawQuery # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RawQuery -> m RawQuery #
Generic RawQuery #
Instance details Defined in Napkin.Types.Core Associated Types type Rep RawQuery :: Type -> Type # Methods from :: RawQuery -> Rep RawQuery x # to :: Rep RawQuery x -> RawQuery #
Show RawQuery #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> RawQuery -> ShowS # show :: RawQuery -> String # showList :: [RawQuery] -> ShowS #
NFData RawQuery #
Instance details Defined in Napkin.Types.Core Methods rnf :: RawQuery -> () #
Eq RawQuery #
Instance details Defined in Napkin.Types.Core Methods (==) :: RawQuery -> RawQuery -> Bool # (/=) :: RawQuery -> RawQuery -> Bool #
Ord RawQuery #
Instance details Defined in Napkin.Types.Core Methods compare :: RawQuery -> RawQuery -> Ordering # (<) :: RawQuery -> RawQuery -> Bool # (<=) :: RawQuery -> RawQuery -> Bool # (>) :: RawQuery -> RawQuery -> Bool # (>=) :: RawQuery -> RawQuery -> Bool # max :: RawQuery -> RawQuery -> RawQuery # min :: RawQuery -> RawQuery -> RawQuery #
Lift RawQuery #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => RawQuery -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => RawQuery -> Code m RawQuery #
type Rep RawQuery #
Instance details Defined in Napkin.Types.Core type Rep RawQuery = D1 ('MetaData "RawQuery" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "RawQuery" 'PrefixI 'True) (S1 ('MetaSel ('Just "_rawQuery_deps") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Ref Table]) :*: S1 ('MetaSel ('Just "_rawQuery_raw") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))

data CteBody #

Constructors

JustCteBody (Selected Query)
PositionalBoundsCteBody (NonEmpty (Ref SExp)) (Selected Query)

Instances

Instances details

Data CteBody #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CteBody -> c CteBody # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CteBody # toConstr :: CteBody -> Constr # dataTypeOf :: CteBody -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CteBody) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CteBody) # gmapT :: (forall b. Data b => b -> b) -> CteBody -> CteBody # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CteBody -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CteBody -> r # gmapQ :: (forall d. Data d => d -> u) -> CteBody -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CteBody -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CteBody -> m CteBody # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CteBody -> m CteBody # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CteBody -> m CteBody #
Generic CteBody #
Instance details Defined in Napkin.Types.Core Associated Types type Rep CteBody :: Type -> Type # Methods from :: CteBody -> Rep CteBody x # to :: Rep CteBody x -> CteBody #
Show CteBody #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> CteBody -> ShowS # show :: CteBody -> String # showList :: [CteBody] -> ShowS #
NFData CteBody #
Instance details Defined in Napkin.Types.Core Methods rnf :: CteBody -> () #
Eq CteBody #
Instance details Defined in Napkin.Types.Core Methods (==) :: CteBody -> CteBody -> Bool # (/=) :: CteBody -> CteBody -> Bool #
Ord CteBody #
Instance details Defined in Napkin.Types.Core Methods compare :: CteBody -> CteBody -> Ordering # (<) :: CteBody -> CteBody -> Bool # (<=) :: CteBody -> CteBody -> Bool # (>) :: CteBody -> CteBody -> Bool # (>=) :: CteBody -> CteBody -> Bool # max :: CteBody -> CteBody -> CteBody # min :: CteBody -> CteBody -> CteBody #
HasDeps CteBody #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: CteBody -> Set (Ref Table) # traverseDependencies :: Fold CteBody (Ref Table) #
FunRenamer CteBody #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> CteBody -> CteBody #
FunctionTransformer CteBody #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> CteBody -> CteBody #
TableRenamer CteBody #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> CteBody -> CteBody #
Lift CteBody #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => CteBody -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => CteBody -> Code m CteBody #
type Rep CteBody #
Instance details Defined in Napkin.Types.Core type Rep CteBody = D1 ('MetaData "CteBody" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "JustCteBody" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Selected Query))) :+: C1 ('MetaCons "PositionalBoundsCteBody" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty (Ref SExp))) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Selected Query))))

data WithClauses #

CTE expression support- the RECURSIVE keyword allows any subsequently mentioned CTEs to be recursive (but are not necessarily recursive).

Constructors

WithClauses
Fields _withClauses_recursive :: Bool _withClauses_cteBodies :: OMap (Ref Query) CteBody

Instances

Instances details

Data WithClauses #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WithClauses -> c WithClauses # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WithClauses # toConstr :: WithClauses -> Constr # dataTypeOf :: WithClauses -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WithClauses) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WithClauses) # gmapT :: (forall b. Data b => b -> b) -> WithClauses -> WithClauses # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WithClauses -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WithClauses -> r # gmapQ :: (forall d. Data d => d -> u) -> WithClauses -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WithClauses -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WithClauses -> m WithClauses # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WithClauses -> m WithClauses # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WithClauses -> m WithClauses #
Generic WithClauses #
Instance details Defined in Napkin.Types.Core Associated Types type Rep WithClauses :: Type -> Type # Methods from :: WithClauses -> Rep WithClauses x # to :: Rep WithClauses x -> WithClauses #
Show WithClauses #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> WithClauses -> ShowS # show :: WithClauses -> String # showList :: [WithClauses] -> ShowS #
Default WithClauses #
Instance details Defined in Napkin.Types.Core Methods def :: WithClauses #
NFData WithClauses #
Instance details Defined in Napkin.Types.Core Methods rnf :: WithClauses -> () #
Eq WithClauses #
Instance details Defined in Napkin.Types.Core Methods (==) :: WithClauses -> WithClauses -> Bool # (/=) :: WithClauses -> WithClauses -> Bool #
Ord WithClauses #
Instance details Defined in Napkin.Types.Core Methods compare :: WithClauses -> WithClauses -> Ordering # (<) :: WithClauses -> WithClauses -> Bool # (<=) :: WithClauses -> WithClauses -> Bool # (>) :: WithClauses -> WithClauses -> Bool # (>=) :: WithClauses -> WithClauses -> Bool # max :: WithClauses -> WithClauses -> WithClauses # min :: WithClauses -> WithClauses -> WithClauses #
HasDeps WithClauses #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: WithClauses -> Set (Ref Table) # traverseDependencies :: Fold WithClauses (Ref Table) #
FunRenamer WithClauses #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> WithClauses -> WithClauses #
FunctionTransformer WithClauses #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> WithClauses -> WithClauses #
TableRenamer WithClauses #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> WithClauses -> WithClauses #
Lift WithClauses #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => WithClauses -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => WithClauses -> Code m WithClauses #
type Rep WithClauses #
Instance details Defined in Napkin.Types.Core type Rep WithClauses = D1 ('MetaData "WithClauses" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "WithClauses" 'PrefixI 'True) (S1 ('MetaSel ('Just "_withClauses_recursive") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool) :*: S1 ('MetaSel ('Just "_withClauses_cteBodies") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (OMap (Ref Query) CteBody))))

orderWithInserted :: WithClauses -> [(Ref Query, CteBody)] #

cteRefs :: WithClauses -> Set (Ref a) #

data AsStruct #

Constructors

AsStruct
AsStructNo
AsValue

Instances

Instances details

Data AsStruct #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AsStruct -> c AsStruct # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AsStruct # toConstr :: AsStruct -> Constr # dataTypeOf :: AsStruct -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AsStruct) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AsStruct) # gmapT :: (forall b. Data b => b -> b) -> AsStruct -> AsStruct # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AsStruct -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AsStruct -> r # gmapQ :: (forall d. Data d => d -> u) -> AsStruct -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AsStruct -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AsStruct -> m AsStruct # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AsStruct -> m AsStruct # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AsStruct -> m AsStruct #
Generic AsStruct #
Instance details Defined in Napkin.Types.Core Associated Types type Rep AsStruct :: Type -> Type # Methods from :: AsStruct -> Rep AsStruct x # to :: Rep AsStruct x -> AsStruct #
Read AsStruct #
Instance details Defined in Napkin.Types.Core Methods readsPrec :: Int -> ReadS AsStruct # readList :: ReadS [AsStruct] # readPrec :: ReadPrec AsStruct # readListPrec :: ReadPrec [AsStruct] #
Show AsStruct #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> AsStruct -> ShowS # show :: AsStruct -> String # showList :: [AsStruct] -> ShowS #
NFData AsStruct #
Instance details Defined in Napkin.Types.Core Methods rnf :: AsStruct -> () #
Eq AsStruct #
Instance details Defined in Napkin.Types.Core Methods (==) :: AsStruct -> AsStruct -> Bool # (/=) :: AsStruct -> AsStruct -> Bool #
Ord AsStruct #
Instance details Defined in Napkin.Types.Core Methods compare :: AsStruct -> AsStruct -> Ordering # (<) :: AsStruct -> AsStruct -> Bool # (<=) :: AsStruct -> AsStruct -> Bool # (>) :: AsStruct -> AsStruct -> Bool # (>=) :: AsStruct -> AsStruct -> Bool # max :: AsStruct -> AsStruct -> AsStruct # min :: AsStruct -> AsStruct -> AsStruct #
Lift AsStruct #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => AsStruct -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => AsStruct -> Code m AsStruct #
type Rep AsStruct #
Instance details Defined in Napkin.Types.Core type Rep AsStruct = D1 ('MetaData "AsStruct" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "AsStruct" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "AsStructNo" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AsValue" 'PrefixI 'False) (U1 :: Type -> Type)))

type Keyword = Ref Function #

data ParensOperatorArgument #

Constructors

ParensOperatorArgument [Keyword] (Alias SExp)
ParensOperatorConst [Keyword]

Instances

Instances details

Data ParensOperatorArgument #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ParensOperatorArgument -> c ParensOperatorArgument # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ParensOperatorArgument # toConstr :: ParensOperatorArgument -> Constr # dataTypeOf :: ParensOperatorArgument -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ParensOperatorArgument) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ParensOperatorArgument) # gmapT :: (forall b. Data b => b -> b) -> ParensOperatorArgument -> ParensOperatorArgument # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ParensOperatorArgument -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ParensOperatorArgument -> r # gmapQ :: (forall d. Data d => d -> u) -> ParensOperatorArgument -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ParensOperatorArgument -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ParensOperatorArgument -> m ParensOperatorArgument # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ParensOperatorArgument -> m ParensOperatorArgument # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ParensOperatorArgument -> m ParensOperatorArgument #
Generic ParensOperatorArgument #
Instance details Defined in Napkin.Types.Core Associated Types type Rep ParensOperatorArgument :: Type -> Type # Methods from :: ParensOperatorArgument -> Rep ParensOperatorArgument x # to :: Rep ParensOperatorArgument x -> ParensOperatorArgument #
Show ParensOperatorArgument #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> ParensOperatorArgument -> ShowS # show :: ParensOperatorArgument -> String # showList :: [ParensOperatorArgument] -> ShowS #
NFData ParensOperatorArgument #
Instance details Defined in Napkin.Types.Core Methods rnf :: ParensOperatorArgument -> () #
Eq ParensOperatorArgument #
Instance details Defined in Napkin.Types.Core Methods (==) :: ParensOperatorArgument -> ParensOperatorArgument -> Bool # (/=) :: ParensOperatorArgument -> ParensOperatorArgument -> Bool #
Ord ParensOperatorArgument #
Instance details Defined in Napkin.Types.Core Methods compare :: ParensOperatorArgument -> ParensOperatorArgument -> Ordering # (<) :: ParensOperatorArgument -> ParensOperatorArgument -> Bool # (<=) :: ParensOperatorArgument -> ParensOperatorArgument -> Bool # (>) :: ParensOperatorArgument -> ParensOperatorArgument -> Bool # (>=) :: ParensOperatorArgument -> ParensOperatorArgument -> Bool # max :: ParensOperatorArgument -> ParensOperatorArgument -> ParensOperatorArgument # min :: ParensOperatorArgument -> ParensOperatorArgument -> ParensOperatorArgument #
Lift ParensOperatorArgument #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => ParensOperatorArgument -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ParensOperatorArgument -> Code m ParensOperatorArgument #
type Rep ParensOperatorArgument #
Instance details Defined in Napkin.Types.Core type Rep ParensOperatorArgument = D1 ('MetaData "ParensOperatorArgument" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "ParensOperatorArgument" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Keyword]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Alias SExp))) :+: C1 ('MetaCons "ParensOperatorConst" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Keyword])))

data ParensOperator #

Constructors

ParensOperator [Ref Function] [ParensOperatorArgument]
ParensLessOperator [Ref Function]

Instances

Instances details

Data ParensOperator #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ParensOperator -> c ParensOperator # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ParensOperator # toConstr :: ParensOperator -> Constr # dataTypeOf :: ParensOperator -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ParensOperator) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ParensOperator) # gmapT :: (forall b. Data b => b -> b) -> ParensOperator -> ParensOperator # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ParensOperator -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ParensOperator -> r # gmapQ :: (forall d. Data d => d -> u) -> ParensOperator -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ParensOperator -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ParensOperator -> m ParensOperator # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ParensOperator -> m ParensOperator # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ParensOperator -> m ParensOperator #
Generic ParensOperator #
Instance details Defined in Napkin.Types.Core Associated Types type Rep ParensOperator :: Type -> Type # Methods from :: ParensOperator -> Rep ParensOperator x # to :: Rep ParensOperator x -> ParensOperator #
Show ParensOperator #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> ParensOperator -> ShowS # show :: ParensOperator -> String # showList :: [ParensOperator] -> ShowS #
NFData ParensOperator #
Instance details Defined in Napkin.Types.Core Methods rnf :: ParensOperator -> () #
Eq ParensOperator #
Instance details Defined in Napkin.Types.Core Methods (==) :: ParensOperator -> ParensOperator -> Bool # (/=) :: ParensOperator -> ParensOperator -> Bool #
Ord ParensOperator #
Instance details Defined in Napkin.Types.Core Methods compare :: ParensOperator -> ParensOperator -> Ordering # (<) :: ParensOperator -> ParensOperator -> Bool # (<=) :: ParensOperator -> ParensOperator -> Bool # (>) :: ParensOperator -> ParensOperator -> Bool # (>=) :: ParensOperator -> ParensOperator -> Bool # max :: ParensOperator -> ParensOperator -> ParensOperator # min :: ParensOperator -> ParensOperator -> ParensOperator #
Lift ParensOperator #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => ParensOperator -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ParensOperator -> Code m ParensOperator #
type Rep ParensOperator #
Instance details Defined in Napkin.Types.Core type Rep ParensOperator = D1 ('MetaData "ParensOperator" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "ParensOperator" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Ref Function]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ParensOperatorArgument])) :+: C1 ('MetaCons "ParensLessOperator" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Ref Function])))

mapSExpOfParensOperatorArg :: (SExp -> SExp) -> ParensOperatorArgument -> ParensOperatorArgument #

type ColumnComment = (Ref SExp, Text) #

data Query #

Constructors

Query
Fields _queryWith :: WithClauses _querySelect :: [Alias SExp] _queryComments :: [ColumnComment] _queryFrom :: Maybe From _queryTableOperator :: Maybe ParensOperator _queryWhere :: Maybe SExp _queryHaving :: Maybe SExp _queryGroup :: GroupBy _queryOrder :: Order _queryLimit :: Maybe Int _queryOffset :: Maybe Int _queryDistinct :: Distinctness _queryAs :: AsStruct
Union
Fields _unionType :: UnionType _unionQuery1 :: Query _unionQuery2 :: Query _unionWiths :: WithClauses unions may share with clauses
QueryRaw RawQuery	Escape hatch: A raw query with all the dependencies contained therein. Avoid if possible.
NativeQuery NativeQuery

Instances

Instances details

Data Query #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Query -> c Query # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Query # toConstr :: Query -> Constr # dataTypeOf :: Query -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Query) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Query) # gmapT :: (forall b. Data b => b -> b) -> Query -> Query # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Query -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Query -> r # gmapQ :: (forall d. Data d => d -> u) -> Query -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Query -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Query -> m Query # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Query -> m Query # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Query -> m Query #
Generic Query #
Instance details Defined in Napkin.Types.Core Associated Types type Rep Query :: Type -> Type # Methods from :: Query -> Rep Query x # to :: Rep Query x -> Query #
Show Query #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> Query -> ShowS # show :: Query -> String # showList :: [Query] -> ShowS #
NFData Query #
Instance details Defined in Napkin.Types.Core Methods rnf :: Query -> () #
Eq Query #
Instance details Defined in Napkin.Types.Core Methods (==) :: Query -> Query -> Bool # (/=) :: Query -> Query -> Bool #
Ord Query #
Instance details Defined in Napkin.Types.Core Methods compare :: Query -> Query -> Ordering # (<) :: Query -> Query -> Bool # (<=) :: Query -> Query -> Bool # (>) :: Query -> Query -> Bool # (>=) :: Query -> Query -> Bool # max :: Query -> Query -> Query # min :: Query -> Query -> Query #
AsRelation Query #
Instance details Defined in Napkin.Types.Core Methods asRelation :: Query -> Relation #
HasDefinition Query #
Instance details Defined in Napkin.Types.Core Methods defQuery :: Lens Query Query Query Query #
MaybeQuery Query #
Instance details Defined in Napkin.Types.Core Methods getQuery :: Query -> Maybe Query #
HasDeps Query #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: Query -> Set (Ref Table) # traverseDependencies :: Fold Query (Ref Table) #
FunRenamer Query #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> Query -> Query #
FunctionTransformer Query #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> Query -> Query #
TableRenamer Query #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Query -> Query #
RenderSql Query BigQuery #
Instance details Defined in Napkin.Render.BigQuery Methods renderSql :: BigQuery -> Query -> Doc #
RenderSql Query MsSql #
Instance details Defined in Napkin.Render.MsSql Methods renderSql :: MsSql -> Query -> Doc #
RenderSql Query Postgres #
Instance details Defined in Napkin.Render.Postgres Methods renderSql :: Postgres -> Query -> Doc #
RenderSql Query Redshift #
Instance details Defined in Napkin.Render.Redshift Methods renderSql :: Redshift -> Query -> Doc #
RenderSql Query Sqlite #
Instance details Defined in Napkin.Render.Sqlite Methods renderSql :: Sqlite -> Query -> Doc #
Lift Query #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => Query -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Query -> Code m Query #
FunRenamer (Selected Query) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameFun :: (Ref Function -> Ref Function) -> Selected Query -> Selected Query #
FunctionTransformer (Selected Query) #
Instance details Defined in Napkin.Types.QueryTransformer Methods modFun :: (ExternFun -> SExp) -> Selected Query -> Selected Query #
TableRenamer (Selected Query) #
Instance details Defined in Napkin.Types.QueryTransformer Methods renameTableRef :: (Ref Table -> Ref Table) -> Selected Query -> Selected Query #
type Rep Query #
Instance details Defined in Napkin.Types.Core type Rep Query = D1 ('MetaData "Query" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) ((C1 ('MetaCons "Query" 'PrefixI 'True) (((S1 ('MetaSel ('Just "_queryWith") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 WithClauses) :: (S1 ('MetaSel ('Just "_querySelect") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Alias SExp]) :: S1 ('MetaSel ('Just "_queryComments") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ColumnComment]))) :: (S1 ('MetaSel ('Just "_queryFrom") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe From)) :: (S1 ('MetaSel ('Just "_queryTableOperator") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ParensOperator)) :: S1 ('MetaSel ('Just "_queryWhere") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SExp))))) :: ((S1 ('MetaSel ('Just "_queryHaving") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SExp)) :: (S1 ('MetaSel ('Just "_queryGroup") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 GroupBy) :: S1 ('MetaSel ('Just "_queryOrder") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Order))) :: ((S1 ('MetaSel ('Just "_queryLimit") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Int)) :: S1 ('MetaSel ('Just "_queryOffset") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Int))) :: (S1 ('MetaSel ('Just "_queryDistinct") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Distinctness) :: S1 ('MetaSel ('Just "_queryAs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AsStruct))))) :+: C1 ('MetaCons "Union" 'PrefixI 'True) ((S1 ('MetaSel ('Just "_unionType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 UnionType) :: S1 ('MetaSel ('Just "_unionQuery1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Query)) :: (S1 ('MetaSel ('Just "_unionQuery2") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Query) :*: S1 ('MetaSel ('Just "_unionWiths") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 WithClauses)))) :+: (C1 ('MetaCons "QueryRaw" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RawQuery)) :+: C1 ('MetaCons "NativeQuery" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NativeQuery))))

data NativeQuery #

Constructors

PostgresSelectStmt SelectStmt
SimpleSQLParserQueryExpr QueryExpr

Instances

Instances details

Data NativeQuery #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NativeQuery -> c NativeQuery # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NativeQuery # toConstr :: NativeQuery -> Constr # dataTypeOf :: NativeQuery -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NativeQuery) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NativeQuery) # gmapT :: (forall b. Data b => b -> b) -> NativeQuery -> NativeQuery # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NativeQuery -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NativeQuery -> r # gmapQ :: (forall d. Data d => d -> u) -> NativeQuery -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NativeQuery -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NativeQuery -> m NativeQuery # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NativeQuery -> m NativeQuery # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NativeQuery -> m NativeQuery #
Generic NativeQuery #
Instance details Defined in Napkin.Types.Core Associated Types type Rep NativeQuery :: Type -> Type # Methods from :: NativeQuery -> Rep NativeQuery x # to :: Rep NativeQuery x -> NativeQuery #
Show NativeQuery #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> NativeQuery -> ShowS # show :: NativeQuery -> String # showList :: [NativeQuery] -> ShowS #
NFData NativeQuery #
Instance details Defined in Napkin.Types.Core Methods rnf :: NativeQuery -> () #
Eq NativeQuery #
Instance details Defined in Napkin.Types.Core Methods (==) :: NativeQuery -> NativeQuery -> Bool # (/=) :: NativeQuery -> NativeQuery -> Bool #
Ord NativeQuery #
Instance details Defined in Napkin.Types.Core Methods compare :: NativeQuery -> NativeQuery -> Ordering # (<) :: NativeQuery -> NativeQuery -> Bool # (<=) :: NativeQuery -> NativeQuery -> Bool # (>) :: NativeQuery -> NativeQuery -> Bool # (>=) :: NativeQuery -> NativeQuery -> Bool # max :: NativeQuery -> NativeQuery -> NativeQuery # min :: NativeQuery -> NativeQuery -> NativeQuery #
ToDbBackend anyBackend => RenderSql NativeQuery anyBackend #
Instance details Defined in Napkin.Render.Native Methods renderSql :: anyBackend -> NativeQuery -> Doc #
Lift NativeQuery #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => NativeQuery -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => NativeQuery -> Code m NativeQuery #
type Rep NativeQuery #
Instance details Defined in Napkin.Types.Core type Rep NativeQuery = D1 ('MetaData "NativeQuery" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "PostgresSelectStmt" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SelectStmt)) :+: C1 ('MetaCons "SimpleSQLParserQueryExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 QueryExpr)))

emptyQuery :: Query #

mkUnion :: UnionType -> [Query] -> Query #

Convenience: Combine list of queries via union of the same type

collectUnionQueries :: Query -> NonEmpty Query #

Pull apart any UNIONs and extract a flat list of non-union queries.

data DefinedRelation #

OO-style wrapper for objects that contain a full query definition

Constructors

forall s.(AsRelation s, HasDefinition s, MaybeQuery s) => DefinedRelation s

Instances

Instances details

AsRelation DefinedRelation #
Instance details Defined in Napkin.Types.Core Methods asRelation :: DefinedRelation -> Relation #

data DefinedQuery #

Like DefinedRelation, but only requires a defined query.

Constructors

forall s.HasDefinition s => DefinedQuery s

class AsRelation s where #

Methods

asRelation :: s -> Relation #

Instances

Instances details

AsRelation DefinedRelation #
Instance details Defined in Napkin.Types.Core Methods asRelation :: DefinedRelation -> Relation #
AsRelation Query #
Instance details Defined in Napkin.Types.Core Methods asRelation :: Query -> Relation #
AsRelation Relation #
Instance details Defined in Napkin.Types.Core Methods asRelation :: Relation -> Relation #
AsRelation SpecTableName #
Instance details Defined in Napkin.Types.Core Methods asRelation :: SpecTableName -> Relation #
AsRelation (CreateTableAs m) #
Instance details Defined in Napkin.Spec.Types.CreateTableAs Methods asRelation :: CreateTableAs m -> Relation #
AsRelation (CreateTable m) #
Instance details Defined in Napkin.Types.Commands Methods asRelation :: CreateTable m -> Relation #
AsRelation (CreateView meta) #
Instance details Defined in Napkin.Types.Commands Methods asRelation :: CreateView meta -> Relation #
AsRelation (Q a) #
Instance details Defined in Napkin.Untyped.Monad Methods asRelation :: Q a -> Relation #
AsRelation (Ref a) #
Instance details Defined in Napkin.Types.Core Methods asRelation :: Ref a -> Relation #

class HasDefinition s where #

Methods

defQuery :: Lens s s Query Query #

Instances

Instances details

HasDefinition Query #
Instance details Defined in Napkin.Types.Core Methods defQuery :: Lens Query Query Query Query #
HasDefinition (CreateTableAs m) #
Instance details Defined in Napkin.Spec.Types.CreateTableAs Methods defQuery :: Lens (CreateTableAs m) (CreateTableAs m) Query Query #
HasDefinition (CreateTable m) #
Instance details Defined in Napkin.Types.Commands Methods defQuery :: Lens (CreateTable m) (CreateTable m) Query Query #
HasDefinition (Q ()) #
Instance details Defined in Napkin.Untyped.Monad Methods defQuery :: Lens (Q ()) (Q ()) Query Query #

class MaybeQuery s where #

Things that may or may not contain an explicit Query inside

Methods

getQuery :: s -> Maybe Query #

Instances

Instances details

MaybeQuery Query #
Instance details Defined in Napkin.Types.Core Methods getQuery :: Query -> Maybe Query #
MaybeQuery Relation #
Instance details Defined in Napkin.Types.Core Methods getQuery :: Relation -> Maybe Query #
MaybeQuery (CreateTableAs m) #
Instance details Defined in Napkin.Spec.Types.CreateTableAs Methods getQuery :: CreateTableAs m -> Maybe Query #
MaybeQuery (CreateTable m) #
Instance details Defined in Napkin.Types.Commands Methods getQuery :: CreateTable m -> Maybe Query #
MaybeQuery (Q ()) #
Instance details Defined in Napkin.Untyped.Monad Methods getQuery :: Q () -> Maybe Query #

queryFullySpecified :: Data a => a -> Bool #

Has select * been used anywhere inside this thing? If so, False.

opOrder :: Lens' OrderPart OrderDir #

opNulls :: Lens' OrderPart (Maybe NullOrder) #

opExp :: Lens' OrderPart SExp #

rawQuery_raw :: Lens' RawQuery String #

rawQuery_deps :: Lens' RawQuery [Ref Table] #

unionWiths :: Traversal' Query WithClauses #

unionType :: Traversal' Query UnionType #

unionQuery2 :: Traversal' Query Query #

unionQuery1 :: Traversal' Query Query #

queryWith :: Traversal' Query WithClauses #

queryWhere :: Traversal' Query (Maybe SExp) #

queryTableOperator :: Traversal' Query (Maybe ParensOperator) #

querySelect :: Traversal' Query [Alias SExp] #

queryOrder :: Traversal' Query Order #

queryOffset :: Traversal' Query (Maybe Int) #

queryLimit :: Traversal' Query (Maybe Int) #

queryHaving :: Traversal' Query (Maybe SExp) #

queryGroup :: Traversal' Query GroupBy #

queryFrom :: Traversal' Query (Maybe From) #

queryDistinct :: Traversal' Query Distinctness #

queryComments :: Traversal' Query [ColumnComment] #

queryAs :: Traversal' Query AsStruct #

_NativeQuery :: Prism' Query NativeQuery #

_QueryRaw :: Prism' Query RawQuery #

_Union :: Prism' Query (UnionType, Query, Query, WithClauses) #

_Query :: Prism' Query (WithClauses, [Alias SExp], [ColumnComment], Maybe From, Maybe ParensOperator, Maybe SExp, Maybe SExp, GroupBy, Order, Maybe Int, Maybe Int, Distinctness, AsStruct) #

_From :: Iso' From (Selected Relation, [(Selected Relation, JoinType, Either (Maybe SExp) [Ref SExp])]) #

_Star :: Prism' Name () #

_Specific :: Prism' Name SrcLitStr #

_JoinOuter :: Prism' JoinType () #

_JoinCross :: Prism' JoinType () #

_JoinInner :: Prism' JoinType () #

_JoinRight :: Prism' JoinType () #

_JoinLeft :: Prism' JoinType () #

_RawRelation :: Prism' Relation ([Ref Table], String) #

_ArrayRelation :: Prism' Relation SExp #

_QueryRelation :: Prism' Relation Query #

_TableRelation :: Prism' Relation (Ref Table) #

unRef :: forall k (a :: k) k (a :: k). Iso (Ref (a :: k)) (Ref (a :: k)) (NonEmpty Name) (NonEmpty Name) #

_VDatePart :: Prism' Value DatePart #

_VNull :: Prism' Value () #

_VInterval :: Prism' Value Interval #

_VBinary :: Prism' Value ByteString #

_VText :: Prism' Value SrcLitStr #

_VDateTime :: Prism' Value UTCTime #

_VDate :: Prism' Value Day #

_VBool :: Prism' Value Bool #

_VInt :: Prism' Value Int64 #

_VDouble :: Prism' Value Double #

_Microsecond :: Prism' DatePart () #

_Millisecond :: Prism' DatePart () #

_Second :: Prism' DatePart () #

_Minute :: Prism' DatePart () #

_Hour :: Prism' DatePart () #

_Day :: Prism' DatePart () #

_DayOfYear :: Prism' DatePart () #

_DayOfWeek :: Prism' DatePart () #

_Week :: Prism' DatePart () #

_Month :: Prism' DatePart () #

_Quarter :: Prism' DatePart () #

_Year :: Prism' DatePart () #

_Epoch :: Prism' DatePart () #

_Decade :: Prism' DatePart () #

_Century :: Prism' DatePart () #

_Millennium :: Prism' DatePart () #

_NativeExpr :: Prism' SExp NativeExpr #

_SubQuery :: Prism' SExp Query #

_ExceptColumns :: Prism' SExp (SExp, [Ref SExp]) #

_Case :: Prism' SExp ([(SExp, SExp)], SExp) #

_Extern :: Prism' SExp ExternFun #

_FieldAccess :: Prism' SExp (SExp, StructField) #

_Struct :: Prism' SExp (Maybe (OMap StructField Type), OMap StructField SExp) #

_Array :: Prism' SExp (Maybe Type, [SExp]) #

_ArrayItem :: Prism' SExp (ArrayBase, Nullability, SExp, SExp) #

_ArraySelect :: Prism' SExp Query #

_Var :: Prism' SExp (Ref SExp) #

_Lit :: Prism' SExp Value #

selectRef :: forall a. Lens' (Selected a) (Ref a) #

selectItem :: forall a. Lens' (Selected a) a #

aliasRef :: forall a. Lens' (Alias a) (Maybe (Ref a)) #

aliasItem :: forall a. Lens' (Alias a) a #

overPartition :: Lens' WOver Partition #

overOrder :: Lens' WOver Order #

overFrame :: Lens' WOver (Maybe WindowFrame) #

normalizedRef :: Iso' NormalizedTable (Ref Table) #

tableKind :: Lens' ListedTable ListedTableKind #

normalized :: Lens' ListedTable NormalizedTable #

unName :: Traversal' Name SrcLitStr #

withClauses_recursive :: Lens' WithClauses Bool #

withClauses_cteBodies :: Lens' WithClauses (OMap (Ref Query) CteBody) #

_WithClauses :: Iso' WithClauses (Bool, OMap (Ref Query) CteBody) #

allQueryComments :: Lens' Query [ColumnComment] #

refNamespace :: Lens' (Ref a) (Maybe Name) #

class Val a where #

Methods

val :: Prism' Value a #

Instances

Instances details

Val Int64 #	Auto-convert from `VText`
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value Int64 #
Val ByteString #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value ByteString #
Val DatePart #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value DatePart #
Val IntInterval #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value IntInterval #
Val Value #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value Value #
Val Text #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value Text #
Val Day #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value Day #
Val UTCTime #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value UTCTime #
Val String #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value String #
Val Integer #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value Integer #
Val Bool #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value Bool #
Val Double #	Auto-convert from `VInt` and VText
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value Double #
Val Int #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value Int #
Val a => Val (Maybe a) #
Instance details Defined in Napkin.Types.Core Methods val :: Prism' Value (Maybe a) #

convS :: Lens' Text String #

integral :: (Integral a, Integral b) => Iso' a b #

_lit :: Val a => Prism' SExp a #

lit :: Val a => a -> SExp #

interval :: [(Double, DatePart)] -> SExp #

Shorthand for using literal Doubles in making interval expressions.

txt :: String -> SExp #

Monomorphic converter to make it easy to type string literals under OverloadedStrings

fullWindow :: WOver #

Convenient starting point for full window (unbounded) for cases where not specifying window defaults to a partial window. (E.g. BigQuery)

class TableRef a where #

Methods

tableRef :: Lens' a (Ref Table) #

Instances

Instances details

TableRef DeleteFrom #
Instance details Defined in Napkin.Types.Commands Methods tableRef :: Lens' DeleteFrom (Ref Table) #
TableRef DropView #
Instance details Defined in Napkin.Types.Commands Methods tableRef :: Lens' DropView (Ref Table) #
TableRef InsertIntoQuery #
Instance details Defined in Napkin.Types.Commands Methods tableRef :: Lens' InsertIntoQuery (Ref Table) #
TableRef SpecTableName #
Instance details Defined in Napkin.Types.Core Methods tableRef :: Lens' SpecTableName (Ref Table) #
TableRef (CreateTableAs m) #
Instance details Defined in Napkin.Spec.Types.CreateTableAs Methods tableRef :: Lens' (CreateTableAs m) (Ref Table) #
TableRef (CreateTable m) #
Instance details Defined in Napkin.Types.Commands Methods tableRef :: Lens' (CreateTable m) (Ref Table) #
TableRef (CreateView meta) #
Instance details Defined in Napkin.Types.Commands Methods tableRef :: Lens' (CreateView meta) (Ref Table) #
TableRef (Ref Table) #
Instance details Defined in Napkin.Types.Core Methods tableRef :: Lens' (Ref Table) (Ref Table) #

relationRef :: TableRef a => Getter a Relation #

varAs :: Ref a -> Selected SExp #

Polymorphic to support refs that come out of Relations, etc.

asSelf :: SExp -> Selected SExp #

"Note that this is a partial function and will work only for SExps that are Var's. Please prefer varAs or as when possible

funAs :: (SExp -> b) -> Ref b -> Selected b #

Apply function to a Ref and select it by the same name as the ref. Common use case in SELECT queries.

selectToRef :: Selected SExp -> SExp #

Use the name of a Selected as a reference. Typically when you've computed a field in a subquery or a previous table, and you're now using that computation directly via its name.

selectedExps :: Traversal' [Selected a] a #

selectedNames :: Traversal' [Selected a0] String #

refName :: Traversal (Ref a) (Ref a1) String String #

Pull the last name out of a Ref. E.g. if Ref contains a schema.table_name, pull just the table_name out.

refLitName :: Traversal (Ref a) (Ref a1) SrcLitStr SrcLitStr #

Pull the last name out of a Ref e.g. if Ref "schema"."table_name", pull just "table_name". String type preserves quotation/encoding even after prepending/appending a string to it or modification through regex.

refRoot :: Lens' (Ref a) Name #

Get final segments on the ref path and grab the name

refJustRoot :: Ref a -> Ref a #

refParentRoot :: Ref a -> ([String], Maybe String) #

ne :: Iso' [a] (NonEmpty a) #

selectedName :: Traversal' (Selected a) Name #

atAlias :: (Applicative f, Choice p) => Ref t -> Optic' p f (Alias t) (Alias t) #

aliasedNames :: HasDefinition s => Traversal' s (Ref SExp) #

viewAliasedNames :: (MaybeQuery s, Applicative f, Contravariant f) => (Ref SExp -> f (Ref SExp)) -> s -> f s #

scopeRefs :: Data b => Ref t -> b -> b #

Attach all column references within expression to given (table) reference. Note this would replace both their use as variables and in naming the aliases.

scopeExps :: Data b => Ref t -> b -> b #

Modify all variable references in the given object to use the given reference as the hierarchical source of the variable. Useful when pointing all variables to belong to a given relationtablename in a context.

modifyExterns :: Data b => (ExternFun -> SExp) -> b -> b #

(^^.) :: Ref Relation -> Name -> SExp infixl 9 #

Attach given name on the relation

data AggLevel #

Constructors

Unit	Expression is at the row level
Agg	Aggregate functions, like `sum`
Analytic	Analytic level (some backends)

Instances

Instances details

Data AggLevel #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AggLevel -> c AggLevel # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AggLevel # toConstr :: AggLevel -> Constr # dataTypeOf :: AggLevel -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AggLevel) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AggLevel) # gmapT :: (forall b. Data b => b -> b) -> AggLevel -> AggLevel # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AggLevel -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AggLevel -> r # gmapQ :: (forall d. Data d => d -> u) -> AggLevel -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AggLevel -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AggLevel -> m AggLevel # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AggLevel -> m AggLevel # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AggLevel -> m AggLevel #
Show AggLevel #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> AggLevel -> ShowS # show :: AggLevel -> String # showList :: [AggLevel] -> ShowS #
Eq AggLevel #
Instance details Defined in Napkin.Types.Core Methods (==) :: AggLevel -> AggLevel -> Bool # (/=) :: AggLevel -> AggLevel -> Bool #
Ord AggLevel #
Instance details Defined in Napkin.Types.Core Methods compare :: AggLevel -> AggLevel -> Ordering # (<) :: AggLevel -> AggLevel -> Bool # (<=) :: AggLevel -> AggLevel -> Bool # (>) :: AggLevel -> AggLevel -> Bool # (>=) :: AggLevel -> AggLevel -> Bool # max :: AggLevel -> AggLevel -> AggLevel # min :: AggLevel -> AggLevel -> AggLevel #

data UpdateQuery #

Constructors

UpdateQuery
Fields _updateQueryTarget :: Alias (Ref Table) _updateQuerySet :: OMap Name SExp _updateQueryFrom :: Maybe From _updateQueryWhere :: Maybe SExp

Instances

Instances details

Data UpdateQuery #
Instance details Defined in Napkin.Types.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UpdateQuery -> c UpdateQuery # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UpdateQuery # toConstr :: UpdateQuery -> Constr # dataTypeOf :: UpdateQuery -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UpdateQuery) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UpdateQuery) # gmapT :: (forall b. Data b => b -> b) -> UpdateQuery -> UpdateQuery # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UpdateQuery -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UpdateQuery -> r # gmapQ :: (forall d. Data d => d -> u) -> UpdateQuery -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UpdateQuery -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UpdateQuery -> m UpdateQuery # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UpdateQuery -> m UpdateQuery # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UpdateQuery -> m UpdateQuery #
Generic UpdateQuery #
Instance details Defined in Napkin.Types.Core Associated Types type Rep UpdateQuery :: Type -> Type # Methods from :: UpdateQuery -> Rep UpdateQuery x # to :: Rep UpdateQuery x -> UpdateQuery #
Show UpdateQuery #
Instance details Defined in Napkin.Types.Core Methods showsPrec :: Int -> UpdateQuery -> ShowS # show :: UpdateQuery -> String # showList :: [UpdateQuery] -> ShowS #
NFData UpdateQuery #
Instance details Defined in Napkin.Types.Core Methods rnf :: UpdateQuery -> () #
Eq UpdateQuery #
Instance details Defined in Napkin.Types.Core Methods (==) :: UpdateQuery -> UpdateQuery -> Bool # (/=) :: UpdateQuery -> UpdateQuery -> Bool #
Ord UpdateQuery #
Instance details Defined in Napkin.Types.Core Methods compare :: UpdateQuery -> UpdateQuery -> Ordering # (<) :: UpdateQuery -> UpdateQuery -> Bool # (<=) :: UpdateQuery -> UpdateQuery -> Bool # (>) :: UpdateQuery -> UpdateQuery -> Bool # (>=) :: UpdateQuery -> UpdateQuery -> Bool # max :: UpdateQuery -> UpdateQuery -> UpdateQuery # min :: UpdateQuery -> UpdateQuery -> UpdateQuery #
HasDeps UpdateQuery #
Instance details Defined in Napkin.Types.Deps Methods dependenciesSet :: UpdateQuery -> Set (Ref Table) # traverseDependencies :: Fold UpdateQuery (Ref Table) #
(RenderSql SExp b, RenderSql Name b, RenderSql From b, RenderSql (Alias (Ref Table)) b) => RenderSql UpdateQuery b #
Instance details Defined in Napkin.Render.Common Methods renderSql :: b -> UpdateQuery -> Doc #
Lift UpdateQuery #
Instance details Defined in Napkin.Types.Core Methods lift :: Quote m => UpdateQuery -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => UpdateQuery -> Code m UpdateQuery #
Command UpdateQuery () BigQuery #
Instance details Defined in Napkin.Run.BigQuery Methods execCommand :: MonadNapkin BigQuery m => BackendConn BigQuery -> UpdateQuery -> m () #
Command UpdateQuery () MsSql #
Instance details Defined in Napkin.Run.MsSql Methods execCommand :: MonadNapkin MsSql m => BackendConn MsSql -> UpdateQuery -> m () #
Command UpdateQuery () Postgres #
Instance details Defined in Napkin.Run.Postgres Methods execCommand :: MonadNapkin Postgres m => BackendConn Postgres -> UpdateQuery -> m () #
Command UpdateQuery () Redshift #
Instance details Defined in Napkin.Run.Redshift Methods execCommand :: MonadNapkin Redshift m => BackendConn Redshift -> UpdateQuery -> m () #
Command UpdateQuery () Sqlite #
Instance details Defined in Napkin.Run.Sqlite Methods execCommand :: MonadNapkin Sqlite m => BackendConn Sqlite -> UpdateQuery -> m () #
type Rep UpdateQuery #
Instance details Defined in Napkin.Types.Core type Rep UpdateQuery = D1 ('MetaData "UpdateQuery" "Napkin.Types.Core" "napkin-0.5.14-JrXUGmKUOt9J0meJSj0Kh4" 'False) (C1 ('MetaCons "UpdateQuery" 'PrefixI 'True) ((S1 ('MetaSel ('Just "_updateQueryTarget") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Alias (Ref Table))) :: S1 ('MetaSel ('Just "_updateQuerySet") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (OMap Name SExp))) :: (S1 ('MetaSel ('Just "_updateQueryFrom") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe From)) :*: S1 ('MetaSel ('Just "_updateQueryWhere") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SExp)))))

updateQueryWhere :: Lens' UpdateQuery (Maybe SExp) #

updateQueryTarget :: Lens' UpdateQuery (Alias (Ref Table)) #

updateQuerySet :: Lens' UpdateQuery (OMap Name SExp) #

updateQueryFrom :: Lens' UpdateQuery (Maybe From) #

pattern NapkinTablePrefix :: (Eq a, IsString a) => a #

pattern NapkinTableSeparator :: (Eq a, IsString a) => a #

isTemporaryTable :: Ref Table -> Bool #

tmpTableNameFormat :: UTCTime -> Text -> Text #

Temporary tables name format: _np_POSIXtimestamp_token[_tablename], timestamps are used for temporary tables cleanup command

getUTCTimeTemporaryTable :: Ref Table -> Maybe UTCTime #

extracts timestamp from temporary tables name format (tmpTableNameFormat function): _np_day-utc-timestamp_seconds-utc-timestamp_token[_tablename]

getTemporaryTableName :: MonadIO m => m (Ref b) #

TySmallInt
TyInteger
TyBigInt
TyDecimal
TyReal
TyDouble
TyBool
TyChar
TyVarChar
TyBlob
TyUnknown OriginTypeName
TyVarCharWithLen Int
TyDate
TyTimestamp
TyDatetime
TyInterval
TyLimited Type Int
Ty2DLimited Type Int Int
TyArray Type (Maybe Int)
TyStruct (OMap StructField Type)