h$<`q       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None '(-/023589>? beam-coreA type error directing the user to use an explicitly sized integers, instead of   or  .None '(-/023589>?$    None '(-/023589>? # beam-core,Support for NULLable Foreign Key references. data MyTable f = MyTable { nullableRef :: PrimaryKey AnotherTable (Nullable f) , ... } deriving (Generic, Typeable)See Columnar for more information.$ beam-corenewtype mainly used to inspect the tag structure of a particular Beamable. Prevents overlapping instances in some case. Usually not used in end-user code.% beam-coreClass for all Beam backends& beam-coreRequirements to marshal a certain type from a database of a particular backend#$%&%&$#None" '(-./023589>?"( beam-coreParses a beam row. This should not fail, except in the case of an internal bug in beam deserialization code. If it does fail, this should throw a BeamRowParseError.0 beam-coreAn error that may occur when parsing a row. Contains an optional annotation of which column was being parsed (if available).4 beam-coreThe exact error encountered'()*+,.-/0123456789:;<=,.-/*+<=456789:;0123'()None  '(-./023589>?' beam-coreCompare the first and second argument for nullable equality, if they are both not null, return the result of the third expressionSome backends, like  beam-postgres totally ignore the third result, because all equality there is sensible. beam-coreCompare the first and second argument for nullable equality, if they are both not null, return the result of the third expressionSome backends, like  beam-postgres totally ignore the third result, because all equality there is sensible. beam-coreIncluded so that we can easily write a Num instance, but not defined in SQL92. Implementations that do not support this, should use CASE .. WHEN .. beam-coreWhether or not the DELETE command supports aliases beam-core0Type classes for syntaxes which can be displayed beam-coreRender the syntax as a  0, representing the SQL expression it stands fort beam-coreSchema  beam-core Table name  beam-coreWith time zone  beam-coreWith time zone  beam-coreWHERE  beam-coreFields beam-core Where clause  beam-corehaving clause  beam-coreLIMIT  beam-coreOFFSET `abhgfecdikjlrqponmstuxwvy{z|~}|~}y{zuxwvstlrqponmikjbhgfecd`aNone '(-/023589>?*`abhgfecdcdijkjlrqpnommnostuxvwvyz{z|}~ None '(-/023589>?/  beam-core0Optional SQL2008 "BIGINT data type" T071 support beam-core2Optional SQL2003 "NTH_VALUE function" T618 support beam-coreOptional SQL2003 "FIRST_VALUE and LAST_VALUE function" T616 support beam-core5Optional SQL2003 "LEAD and LAG function" T615 support beam-core.Optional SQL2003 "NTILE function" T614 support beam-core:Optional SQL2003 "Enhanced numeric functions" T621 support beam-core>Optional SQL2003 "BINARY AND VARBINARY data type" T021 support beam-core:Optional SQL2003 "Elementary OLAP operations" T611 support beam-core8Optional SQL2003 "Advanced OLAP operations" T612 support beam-core:Optional SQL2003 "Elementary OLAP operations" T611 support`abhgfecdcdijkjlrqpnommnostuxvwvyz{z|}~ None! '(-/023589>?34 None! '(-./023589>?< beam-core9Type class for things which are text-like in this backend beam-coreFake backend that cannot deserialize anything, but is useful for testing beam-coreClass for all Beam SQL backends beam-core?@ beam-core The main syntax. A wrapper over  None '(-/023589>?A0 #$%&&'()*+,/.-012348756;9:<=`abhgfecdcdijkjlrqpnommnostuxvwvyz{z|}~ None  '(-/023589>?DpNone! '(-/023589>?s) beam-core.Class to automatically unwrap nested Nullables beam-coreCarry a constraint instance. beam-core8Carry a constraint instance and the value it applies to. beam-coreProvides a number of introspection routines for the beam library. Allows us to "zip" tables with different column tags together. Always instantiate an empty  instance for tables, primary keys, and any type that you would like to embed within either. See the  5https://haskell-beam.github.io/beam/user-guide/modelsmanual& for more information on embedding. beam-core5The big Kahuna! All beam tables implement this class.The kind of all table types is '(Type -> Type) -> Type'. This is because all table types are actually table type constructors. Every table type takes in another type constructor, called the  column tag, and uses that constructor to instantiate the column types. See the documentation for .This class is mostly Generic-derivable. You need only specify a type for the table's primary key and a method to extract the primary key given the table.An example table: data BlogPostT f = BlogPost { _blogPostSlug :: Columnar f Text , _blogPostBody :: Columnar f Text , _blogPostDate :: Columnar f UTCTime , _blogPostAuthor :: PrimaryKey AuthorT f , _blogPostTagline :: Columnar f (Maybe Text) , _blogPostImageGallery :: PrimaryKey ImageGalleryT (Nullable f) } deriving Generic instance Beamable BlogPostT instance Table BlogPostT where data PrimaryKey BlogPostT f = BlogPostId (Columnar f Text) deriving Generic primaryKey = BlogPostId . _blogPostSlug instance Beamable (PrimaryKey BlogPostT)!We can interpret this as follows:The  _blogPostSlug,  _blogPostBody,  _blogPostDate, and _blogPostTagline fields are of types  ,  , UTCTime , and 'Maybe Text' respectfully.Since  _blogPostSlug,  _blogPostBody,  _blogPostDate, _blogPostAuthor, must be provided (i.e, they cannot contain  7), they will be given SQL NOT NULL constraints. _blogPostTagline is declared   so  ) will be stored as NULL in the database. _blogPostImageGallery1 will be allowed to be empty because it uses the # tag modifier.blogPostAuthor references the AuthorT( table (not given here) and is required.blogPostImageGallery references the  ImageGalleryT table (not given here), but this relation is not required (i.e., it may be  . See #). beam-coreA data type representing the types of primary keys for this table. In order to play nicely with the default deriving mechanism, this type must be an instance of . beam-coreGiven a table, this should return the PrimaryKey from the table. By keeping this polymorphic over column, we ensure that the primary key values come directly from the table (i.e., they can't be arbitrary constants) beam-core A form of table all fields . Useful as a parameter to $ when you only care about one table. beam-core!Column tag that ignores the type. beam-coreThe regular Haskell version of the table. Equivalent to 'tbl Identity' beam-coreRepresents a table that contains metadata on its fields. In particular, each field of type 'Columnar f a' is transformed into 'TableField table a'. You can get or update the name of each field by using the  lens. beam-coreMetadata for a field of type ty in table.Essentially a wrapper over the field name, but with a phantom type parameter, so that it forms an appropriate column tag.Usually you use the  function to generate an appropriate naming convention for you, and then modify it with  if necessary. Under this scheme, the field n be renamed using the   instance for  , or the  function. beam-coreThe path that led to this field. Each element is the haskell name of the record field in which this table is stored. beam-coreThe field name beam-coreLike , but with an intermediate  beam-coreIf you declare a function 'Columnar f a -> b' and try to constrain your function by a type class for f, GHC will complain, because f is ambiguous in 'Columnar f a'. For example, 'Columnar Identity (Maybe a) ~ Maybe a' and 'Columnar (Nullable Identity) a ~ Maybe a', so given a type 'Columnar f a', we cannot know the type of f.Thus, if you need to know f, you can instead use 0. Since its a newtype, it carries around the f paramater unambiguously. Internally, it simply wraps 'Columnar f a' beam-coreA short type-alias for %. May shorten your schema definitions beam-coreA type family that we use to "tag" columns in our table datatypes.This is what allows us to use the same table type to hold table data, describe table settings, derive lenses, and provide expressions.The basic rules are Columnar Identity x = x Thus, any Beam table applied to  will yield a simplified version of the data type, that contains just what you'd expect.The # type is used when referencing s that we want to include optionally. For example, if we have a table with a , like the following data BeamTableT f = BeamTableT { _refToAnotherTable :: PrimaryKey AnotherTableT f , ... }9we would typically be required to provide values for the  embedded into  BeamTableT. We can use # to lift this constraint. data BeamTableT f = BeamTableT { _refToAnotherTable :: PrimaryKey AnotherTableT (Nullable f) , ... }Now we can use justRef and  nothingRef1 to refer to this table optionally. The embedded  in _refToAnotherTable0 automatically has its fields converted into   using #. The last  rule is Columnar f x = f xUse this rule if you'd like to parameterize your table type over any other functor. For example, this is used in the query modules to write expressions such as 'TableT QExpr', which returns a table whose fields have been turned into query expressions.The other rules are used within Beam to provide lenses and to expose the inner structure of the data type. beam-coreWhen parameterized by this entity tag, a database type will hold meta-information on the Haskell mappings of database entities. Under the hood, each entity type is transformed into its  type. For tables this includes the table name as well as the corresponding ', which provides names for each column. beam-coreRepresents a meta-description of a particular entityType. Mostly, a wrapper around 'DatabaseEntityDescriptor be entityType', but carries around the  dictionary. beam-core4An entity tag for tables. See the documentation for  or consult the  5https://haskell-beam.github.io/beam/user-guide/modelsmanual for more. beam-coreA newtype wrapper around 'Columnar f a -> Columnar f a' (i.e., an endomorphism between s over f). You usually want to use  or the  7 instance to rename the field, when 'f ~ TableField' beam-coreA newtype wrapper around 'f e -> f e' (i.e., an endomorphism between entity types in f). You usually want to use 4 or another function to contstruct these for you. beam-coreA helper data type that lets you modify a database schema. Converts all entities in the database into functions from that entity to itself. beam-core)Allows introspection into database types.All database types must be of kind '(Type -> Type) -> Type'. If the type parameter is named f', each field must be of the type of f# applied to some type for which an  instance exists.The be type parameter is necessary so that the compiler can ensure that backend-specific entities only work on the proper backend.Entities are documented under  Database.Beam.Schema#entitiesthe corresponding section and in the 9https://haskell-beam.github.io/beam/user-guide/databases/manual beam-core9Default derived function. Do not implement this yourself.The idea is that, for any two databases over particular entity tags f and g, if we can take any entity in f and g# to the corresponding entity in h0 (in the possibly effectful applicative functor m3), then we can transform the two databases over f and g to a database in h , within m.If that doesn't make sense, don't worry. This is mostly beam internal beam-coreAutomatically provide names for tables, and descriptions for tables (using  ). Your database must implement , and must be auto-derivable. For more information on name generation, see the 5https://haskell-beam.github.io/beam/user-guide/modelsmanual beam-core Return a  that does nothing. This is useful if you only want to rename one table. You can do dbModification { tbl1 = modifyTable (\oldNm -> "NewTableName") tableModification } beam-core*Return a table modification (for use with ) that does nothing. Useful if you only want to change the table name, or if you only want to modify a few fields. For example, (tableModification { field1 = "Column1" }is a table modification (where 'f ~ TableField tbl') that changes the column name of field1 to Column1. beam-coreModify a database according to a given modification. Most useful for  to change the name mappings of tables and fields. For example, you can use this to modify the default names of a table db :: DatabaseSettings MyDb db = defaultDbSettings `withDbModification` dbModification { -- Change default name "table1" to "Table_1". Change the name of "table1Field1" to "first_name" table1 = modifyTable (\_ -> "Table_1") (tableModification { table1Field1 = "first_name" } } beam-coreModify a table according to the given field modifications. Invoked by  to apply the modification in the database. Not used as often in user code, but provided for completeness. beam-core Provide an  for s. Allows you to modify the name of the table and provide a modification for each field in the table. See the examples for  for more. beam-core Construct an  to rename any database entity beam-core Construct an ' to set the schema of a database entity beam-core?Change the entity name without consulting the beam-assigned one beam-core Construct an  to rename the fields of a  beam-coreA field modification to rename the field. Also offered under the   instance for 'FieldModification (TableField tbl) a' for convenience. beam-core?} beam-coreAutomatically deduce lenses for a table over any column tag. lenses at global level by doing a top-level pattern match on 9, replacing every column in the pattern with `LensFor  nameOfLensForField'. The lenses are generated per-column, not per field in the record. Thus if you have nested 3 types, lenses are generated for each nested field. For example, data AuthorT f = AuthorT { _authorEmail :: Columnar f Text , _authorFirstName :: Columnar f Text , _authorLastName :: Columnar f Text } deriving Generic data BlogPostT f = BlogPost { _blogPostSlug :: Columnar f Text , _blogPostBody :: Columnar f Text , _blogPostDate :: Columnar f UTCTime , _blogPostAuthor :: PrimaryKey AuthorT f , _blogPostTagline :: Columnar f (Maybe Text) } deriving Generic instance Table BlogPostT where data PrimaryKey BlogPostT f = BlogPostId (Columnar f Text) primaryKey = BlogPostId . _blogPostSlug instance Table AuthorT where data PrimaryKey AuthorT f = AuthorId (Columnar f Text) primaryKey = AuthorId . _authorEmail BlogPost (LensFor blogPostSlug (LensFor blogPostBody) (LensFor blogPostDate) (AuthorId (LensFor blogPostAuthorEmail)) (LensFor blogPostTagLine) = tableLensesNote: In order to have GHC deduce the right type, you will need to turn off the monomorphism restriction. This is a part of the Haskell standard that specifies that top-level definitions must be inferred to have a monomorphic type. However, lenses need a polymorphic type to work properly. You can turn off the monomorphism restriction by enabling the NoMonomorphismRestriction7 extension. You can do this per-file by using the {-$ LANGUAGE NoMonomorphismRestriction ;-} pragma at the top of the file. You can also pass the -XNoMonomorphismRestriction0 command line flag to GHC during compilation. beam-coreLike % but for types that are instances of $. Instead of pattern matching on , pattern match on .None '(-/023589>?~&#&#None! '(-/023589>?` beam-coreTypeclass for all haskell data types that can be used to create a projection in a SQL select statement. This includes all tables as well as all tuple classes. Projections are only defined on tuples up to size 5. If you need more, follow the implementations here. beam-core2s represent expressions not containing aggregates. beam-coreThe type of lifted beam expressions that will yield the haskell type t.context is a type-level representation of the types of expressions this can contain. For example, < represents expressions that may contain aggregates, and , represents expressions that may contain OVER.syntax is the expression syntax being built (usually a type that implements  at least, but not always).s. is a state threading parameter that prevents s from incompatible sources to be combined. For example, this is used to prevent monadic joins from depending on the result of previous joins (so-called LATERAL joins). beam-core&The type of queries over the database db returning results of type a. The s argument is a threading argument meant to restrict cross-usage of s. syntax7 represents the SQL syntax that this query is building. beam-coresuitable as argument to  in the case of a table resultNone! '(-/023589>?V beam-coreConvenience functions to construct an arbitrary SQL92 select syntax type from a :. Used by most backends as the default implementation of  buildSqlQuery in  HasQBuilder. beam-coreWhether this backend supports arbitrary nested UNION, INTERSECT, EXCEPT  beam-core Table prefix None  '(-/023589>?  None '(-/023589>?  beam-core Phantom type representing a SQL  Tri-state$ boolean -- true, false, and unknownThis type has no values because it cannot be sent to or retrieved from the database directly. Use isTrue_, isFalse_,  isNotTrue_,  isNotFalse_,  isUnknown_,  isNotUnknown_, and  unknownAs_ to retrieve the corresponding   value. beam-coreSQL AND operator beam-coreSQL OR operator beam-coreSQL AND operator for  beam-coreSQL OR operator beam-coreSQL LIKE operator beam-coreSQL99  SIMILAR TO operator beam-coreSQL NOT operator beam-coreSQL NOT operator, but operating on  instead beam-coreSQL / operator beam-coreSQL % operator beam-coreSQL CONCAT function 32324477None  '(-/023589>?6$ beam-coreClass for things which can be  quantifiably compared. beam-coreClass for expression types or expression containers for which there is a notion of ordering.Instances are provided to check the ordering of expressions of the same type. Since there is no universal notion of ordering for an arbitrary number of expressions, no instance is provided for  types. beam-coreConstraint synonym to check if two tables can be compared for equality beam-coreClass for Haskell types that can be compared for quantified equality in the given backend beam-coreClass for Haskell types that can be compared for equality in the given backend beam-coreTri-state equality beam-coreTri-state equality beam-core:Class for expression types for which there is a notion of  quantified equality. beam-core)Quantified equality and inequality using  SQL semantics (tri-state boolean) beam-core)Quantified equality and inequality using  SQL semantics (tri-state boolean) beam-coreClass for expression types or expression containers for which there is a notion of equality.Instances are provided to check the equality of expressions of the same type as well as entire  types parameterized over  beam-coreGiven two expressions, returns whether they are equal, using Haskell semantics (NULLs handled properly) beam-coreGiven two expressions, returns whether they are not equal, using Haskell semantics (NULLs handled properly) beam-core#Given two expressions, returns the SQL tri-state boolean when compared for equality beam-core#Given two expressions, returns the SQL tri-state boolean when compared for inequality beam-core%Class for backends which support SQL IN on lists of row values, which is not part of ANSI SQL. This is useful for IN on primary keys. beam-coreSQL IN predicate beam-coreA data structure representing the set to quantify a comparison operator over. beam-core Convert a known not null bool to a . See  for the inverse beam-coreSQL IS TRUE operator beam-coreSQL  IS NOT TRUE operator beam-coreSQL IS FALSE operator beam-coreSQL  IS NOT FALSE operator beam-coreSQL  IS UNKNOWN operator beam-coreSQL IS NOT UNKNOWN operator beam-coreReturn the first argument if the expression has the unknown SQL value See  for the inverse beam-core Retrieve a  value as a potentially NULL  . This is useful if you want to get the value of a SQL boolean expression directly, without having to specify what to do on UNKNOWN. Note that both NULL and UNKNOWN will be returned as  .  beam-coreConvert a possibly NULL   to a .  beam-coreA  representing a SQL ALL(..) for use with a #quantified-comparison-operatorquantified comparison operatorAccepts a subquery. Use   for an explicit list  beam-coreA  representing a SQL ALL(..) for use with a #quantified-comparison-operatorquantified comparison operator3Accepts an explicit list of typed expressions. Use   for a subquery  beam-coreA  representing a SQL ANY(..) for use with a #quantified-comparison-operatorquantified comparison operatorAccepts a subquery. Use   for an explicit list  beam-coreA  representing a SQL ANY(..) for use with a #quantified-comparison-operatorquantified comparison operator3Accepts an explicit list of typed expressions. Use   for a subquery  beam-coreSQL BETWEEN clause  beam-coreCompare two arbitrary  types containing s for equality.  beam-coreCompare two arbitrary expressions (of the same type) for equality  beam-coreTwo arbitrary expressions can be quantifiably compared for equality.1   444444444444444 4None '(-/023589>?  beam-core2Type-class for types that contain a date component  beam-core2Type-class for types that contain a time component  beam-core;A field that can be extracted from SQL expressions of type tgt that results in a type a , in backend be.  beam-core3Extracts the given field from the target expression  beam-coreExtracts the hours, minutes, or seconds from any timestamp or time field  beam-coreExtracts the hours, minutes, or seconds from any timestamp or time field  beam-coreExtracts the hours, minutes, or seconds from any timestamp or time field None  '(-/023589>?  beam-coreA data type in a given 9 which describes a SQL type mapping to the Haskell type a  beam-core6Cast a value to a specific data type, specified using  .Note: this may fail at run-time if the cast is invalid for a particular value  beam-coreSQL92 INTEGER data type  beam-coreSQL92 SMALLINT data type  beam-coreSQL2008 Optional BIGINT data type  beam-coreSQL2003 Optional BINARY data type  beam-coreSQL2003 Optional  VARBINARY data type  beam-coreSQL92 DATE data type  beam-coreSQL92 CHAR data type  beam-coreSQL92 VARCHAR data type  beam-coreSQL92 NATIONAL CHARACTER VARYING data type  beam-coreSQL92 NATIONAL CHARACTER data type  beam-coreSQL92 DOUBLE data type  beam-coreSQL92 NUMERIC data type  beam-coreSQL92 TIMESTAMP WITH TIME ZONE data type  beam-coreSQL92 TIMESTAMP WITHOUT TIME ZONE data type  beam-coreSQL92 TIME data type  beam-coreSQL99 BOOLEAN data type  beam-coreSQL99 CLOB data type  beam-coreSQL99 BLOB data type  beam-coreSQL99 array data types  beam-coreHaskell requires  4s to match exactly. Use this function to convert a  2 that expects a concrete value to one expecting a    None! '(-/023589>?  beam-coreA type-class for expression syntaxes that can embed custom expressions.  beam-core5Given an arbitrary string-like expression, produce a syntax that represents the   as a SQL expression.  beam-coreGiven an arbitrary syntax, produce a string-like value that corresponds to how that syntax would look when rendered in the backend.  beam-coreForce a & to be typed as a value expression (a ). Useful for getting around type-inference errors with supplying the entire type.  beam-coreForce a  to be typed as an aggregate. Useful for defining custom aggregates for use in  aggregate_.  None" '(-/023589>?  beam-coreQuery results that have been introduced into a common table expression via  * that can be used in future queries with  .  beam-coreMonad in which SELECT statements can be made (via  ) and bound to result names for re-use later. This has the advantage of only computing each result once. In SQL, this is translated to a common table expression.?Once introduced, results can be re-used in future queries with  .  is also a member of   for backends that support recursive CTEs. In this case, you can use mdo or rec notation (with  RecursiveDo/ enabled) to bind result values (again, using  ) even before they're introduced.See further documentation  https://haskell-beam.github.io/beam/user-guide/queries/common-table-expressions/here.  beam-coreIntroduce the result of a query as a result in a common table expression. The returned value can be used in future queries by applying  .  beam-core$Introduces the result of a previous   (a CTE) into a new query None '(-/023589>?  beam-core1Introduce a table into a query without using the Beamable and Database machinery.The first argument is the optional name of the schema the table is in and the second is the name of the table to source from.The third argument is a tuple (or any nesting of tuples) where each value is of type   (use   to construct).The return value is a tuple (or any nesting of tuples) of the same shape as  structure but where each value is a .&For example, to source from the table Table1, with fields Field1 (A boolean), Field2 (a timestamp), and Field3 (a string) table_ Nothing "Table1" ( field_ @Bool "Field1", field_ @UTCTime "Field2", field_ @Text "Field3" )  beam-coreUsed to construct  .s, most often with an explicitly applied type.The type can be omitted if the value is used unambiguously elsewhere.  None! '(-/023589>?:  beam-coreType class for anything which can be checked for null-ness. This includes 'QExpr (Maybe a)' as well as s or s over 'Nullable QExpr'.  beam-core Returns a ; that evaluates to true when the first argument is not null  beam-core Returns a 7 that evaluates to true when the first argument is null  beam-coreGiven an object (third argument) which may or may not be null, return the default value if null (first argument), or transform the value that could be null to yield the result of the expression (second argument)  beam-coreType class for things that can be nullable. This includes 'QExpr (Maybe a)', 'tbl (Nullable QExpr)', and 'PrimaryKey tbl (Nullable QExpr)'  beam-coreGiven something of type 'QExpr a', 'tbl QExpr', or 'PrimaryKey tbl QExpr', turn it into a 'QExpr (Maybe a)', 'tbl (Nullable QExpr)', or 'PrimaryKey t (Nullable QExpr)' respectively that contains the same values.  beam-core/Return either a 'QExpr (Maybe x)' representing   or a nullable  or  filled with  .  beam-core Update a  or  type containing s with the given  or  type containing   beam-core*Introduce all entries of a table into the  monad  beam-core)Introduce all entries of a view into the  monad  beam-coreSQL VALUES clause. Introduce the elements of the given list as rows in a joined table.  beam-core*Introduce all entries of a table into the  monad based on the given QExpr. The join condition is expected to return a  . For a version that takes  (a possibly UNKNOWN boolean, that maps more closely to the SQL standard), see  .  beam-coreLike  , but accepting an ON condition that returns   beam-coreIntroduce a table using a left join with no ON clause. Because this is not an inner join, the resulting table is made nullable. This means that each field that would normally have type 'QExpr x' will now have type 'QExpr (Maybe x)'.  beam-core/Outer join. every row of each table, returning NULL for any row of either table for which the join condition finds no related rows.)This expects a join expression returning   , for a version that accepts a  (a possibly UNKNOWN< boolean, that maps more closely to the SQL standard), see   beam-coreLike  , but accepting . Pairs of rows for which the join condition is unknown are considered to be unrelated, by SQL compliant databases at least.  beam-coreIntroduce a table using a left join. The ON clause is required here.Because this is not an inner join, the resulting table is made nullable. This means that each field that would normally have type 'QExpr x' will now have type 'QExpr (Maybe x)'.The ON condition given must return  #. For a version that accepts an ON condition returning , see  .  beam-coreLike  , but accepts an ON clause returning .  beam-core!Only allow results for which the  yields  -. For a version that operates over possibly NULL s, see  .  beam-core!Only allow results for which the  yields TRUE.This function operates over , which are like haskell  s, except for the special UNKNOWN- value that occurs when comparisons include NULL.. For a version that operates over known non-NULL booleans, see  .  beam-core Synonym for +clause >>= \x -> guard_ (mkExpr x)>> pure x. Use   for comparisons with   beam-core Synonym for ,clause >>= \x -> guard_' (mkExpr x)>> pure x. Use   for comparisons with   beam-coreIntroduce all entries of the given table which are referenced by the given   beam-coreIntroduce all entries of the given table for which the expression (which can depend on the queried table returns true)  beam-coreIntroduce all entries of the given table for which the expression (which can depend on the queried table returns true)  beam-core Generate an appropriate boolean  comparing the given foreign key to the given table. Useful for creating join conditions. Use   for a  comparison.  beam-core Generate an appropriate boolean  comparing the given foreign key to the given table. Useful for creating join conditions. Use   for a   comparison.  beam-core(Only return distinct values from a query  beam-core0Limit the number of results returned by a query.  beam-coreDrop the first offset ` results.  beam-core Use the SQL EXISTS= operator to determine if the given query returns any results  beam-core Use the SQL UNIQUE operator to determine if the given query produces a unique result  beam-coreUse the SQL99 DISTINCT operator to determine if the given query produces a distinct result  beam-coreProject the (presumably) singular result of the given query as an expression  beam-coreSQL  CHAR_LENGTH function  beam-coreSQL  OCTET_LENGTH function  beam-coreSQL  BIT_LENGTH function  beam-coreSQL CURRENT_TIMESTAMP function  beam-coreSQL POSITION(.. IN ..) function  beam-coreSQL LOWER function  beam-coreSQL UPPER function  beam-coreSQL TRIM function  beam-coreExtract an expression representing the current (non-UPDATEd) value of a   beam-coreSQL UNION operator  beam-coreSQL  UNION ALL operator  beam-coreSQL  INTERSECT operator  beam-coreSQL  INTERSECT ALL operator  beam-coreSQL EXCEPT operator  beam-coreSQL  EXCEPT ALL operator  beam-coreConvenience function that allows you to use type applications to specify the result of a .$Useful to disambiguate the types of s without having to provide a complete type signature. As an example, the  countAll_) aggregate can return a result of any   type. Without further constraints, the type is ambiguous. You can use  ! to disambiguate the return type.For example, this is ambiguous aggregate_ (\_ -> countAll_) ..But this is not *aggregate_ (\_ -> as_ @Int32 countAll_) ..  beam-core+Specify a window frame with all the options  beam-coreProduce a window expression given an aggregate function and a window.  beam-coreCompute a query over windows.2The first function builds window frames using the  ,  , etc functions. The return type can be a single frame, tuples of frame, or any arbitrarily nested tuple of the above. Instances up to 8-tuples are provided.The second function builds the resulting projection using the result of the subquery as well as the window frames built in the first function. In this function, window expressions can be included in the output using the   function.  beam-coreOrder by the given expressions. The return type of the ordering key should either be the result of   or   (or another ordering  generated by a backend-specific ordering) or an (possibly nested) tuple of results of the former.The  ?https://haskell-beam.github.io/beam/user-guide/queries/orderingmanual section has more information.  beam-core Produce a  corresponding to a SQL ASC ordering  beam-core Produce a  corresponding to a SQL DESC ordering  beam-coreSQL COALESCE support  beam-core Convert a  1 value to a concrete value, by suppling a default  beam-core PARTITION BY  beam-core ORDER BY  beam-core RANGE / ROWS  beam-coreWindow builder function beam-coreProjection builder function. Has access to the windows generated above beam-coreQuery to window over  4 3!None '(-/023589>?  beam-coreConvenience type to declare many-to-many relationships with additional data. See the manual section on  https://haskell-beam.github.io/beam/user-guide/queries/relationships/ relationships for more information  beam-coreConvenience type to declare many-to-many relationships. See the manual section on  https://haskell-beam.github.io/beam/user-guide/queries/relationships/ relationships for more information  beam-coreConvenience type to declare one-to-many relationships with a nullable foreign key. See the manual section on  https://haskell-beam.github.io/beam/user-guide/queries/relationships/ relationships for more information  beam-core Synonym of  . Useful for giving more meaningful types, when the relationship is meant to be one-to-one.  beam-coreConvenience type to declare one-to-many relationships. See the manual section on  https://haskell-beam.github.io/beam/user-guide/queries/relationships/ relationships for more information  beam-core Synonym of  . Useful for giving more meaningful types, when the relationship is meant to be one-to-one.  beam-coreUsed to define one-to-many (or one-to-one) relationships. Takes the table to fetch, a way to extract the foreign key from that table, and the table to relate to.  beam-coreUsed to define one-to-many (or one-to-one) relationships. Takes the table to fetch, a way to extract the foreign key from that table, and the table to relate to.  beam-coreUsed to define one-to-many (or one-to-one) relationships with a nullable foreign key. Takes the table to fetch, a way to extract the foreign key from that table, and the table to relate to.  beam-coreUsed to define one-to-many (or one-to-one) relationships with a nullable foreign key. Takes the table to fetch, a way to extract the foreign key from that table, and the table to relate to.  beam-coreUsed to define many-to-many relationships without any additional data. Takes the join table and two key extraction functions from that table to the related tables. Also takes two +s representing the table sources to relate.See  https://haskell-beam.github.io/beam/user-guide/queries/relationships/ the manual for more information.  beam-coreUsed to define many-to-many relationships with additional data. Takes the join table and two key extraction functions from that table to the related tables. Also takes two +s representing the table sources to relate.See  https://haskell-beam.github.io/beam/user-guide/queries/relationships/ the manual for more information.  beam-coreTable to fetch (many)  beam-core Foreign key  beam-coreTable to fetch (many)  beam-core Foreign key  beam-coreTable to fetch  beam-core Foreign key  beam-coreTable to fetch  beam-core Foreign key "None '(-/023589>?p  beam-coreType class for grouping keys. expr6 is the type of the grouping key after projection. grouped is the type of the grouping key in the aggregate expression (usually something that contains  s in the ).  beam-core"Compute an aggregate over a query.The supplied aggregate projection should return an aggregate expression (an expression containing an aggregate function such as  ,  ,  +, etc), a grouping key (specified with the  7 function), or a combination of tuples of the above.2Appropriate instances are provided up to 8-tuples.Semantically, all grouping expressions in the projection will be added to a SQL GROUP BY7 clause and all aggregate expressions will be computed.The return value will be the type of the aggregate projection, but transformed to be in the normal value context (i.e., everything will become s).For usage examples, see  https://haskell-beam.github.io/beam/user-guide/queries/aggregates/ the manual.  beam-coreCompute an aggregate over all values in a group. Corresponds semantically to the  AGG(ALL ..)) syntax, but doesn't produce an explicit ALL. To produce ALL expicitly, see  .  beam-coreCompute an aggregate only over distinct values in a group. Corresponds to the AGG(DISTINCT ..) syntax.  beam-coreCompute an aggregate over all values in a group. Corresponds to the  AGG(ALL ..) syntax. Note that ALL is the default for most aggregations, so you don't normally explicitly specify ALL. However, if you need to, you can use this function. To be explicit about quantification in the beam query DSL, but not produce an explicit ALL, use  .   has the same semantic meaning, but does not produce an explicit ALL.  beam-coreSQL  MIN(ALL ..)( function (but without the explicit ALL)  beam-coreSQL  MAX(ALL ..)( function (but without the explicit ALL)  beam-coreSQL  AVG(ALL ..)( function (but without the explicit ALL)  beam-coreSQL  SUM(ALL ..)( function (but without the explicit ALL)  beam-coreSQL COUNT(*) function  beam-coreSQL  COUNT(ALL ..)( function (but without the explicit ALL)  beam-coreSQL2003  CUME_DIST: function (Requires T612 Advanced OLAP operations support)  beam-coreSQL2003  PERCENT_RANK: function (Requires T612 Advanced OLAP operations support)  beam-coreSQL2003  DENSE_RANK: function (Requires T612 Advanced OLAP operations support)  beam-coreSQL2003  ROW_NUMBER function  beam-coreSQL2003 RANK< function (Requires T611 Elementary OLAP operations support)  beam-coreSQL EVERY, SOME, and ANY aggregates. Operates over  only, as the result can be NULL0, even if all inputs are known (no input rows).  beam-coreSQL EVERY, SOME, and ANY aggregates. Operates over  only, as the result can be NULL0, even if all inputs are known (no input rows).  beam-coreSQL EVERY, SOME, and ANY aggregates. Operates over  only, as the result can be NULL0, even if all inputs are known (no input rows).  beam-coreSupport for FILTER (WHERE ...) syntax for aggregates. Part of SQL2003 Elementary OLAP operations feature (T611).See   for a version that accepts .  beam-coreLike   but accepting .  beam-coreSQL99  EVERY(ALL ..)( function (but without the explicit ALL)  beam-coreSQL99  SOME(ALL ..)( function (but without the explicit ALL)  beam-coreSQL99  ANY(ALL ..)( function (but without the explicit ALL)  beam-core  for any  type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection  beam-core  for any  type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection  beam-core  for simple value expressions.  beam-coreAggregate projection beam-coreQuery to aggregate over #None '(-/023589>?0  8None '(-/023589>? \$  beam-coreRepresents a SQL DELETE statement for the given table  beam-coreRepresents a SQL UPDATE statement for the given table.  beam-coreRepresents a source of values that can be inserted into a table shaped like tbl.  beam-coreRepresents a SQL INSERT" command that has not yet been run  beam-coreRepresents a select statement in the given backend, returning rows of type a.  beam-core-A version of the table where each field is a   beam-coreBuild a   for the given .  beam-core Create a   for a query which may have common table expressions. See the documentation of   for more details.  beam-core#Convenience function to generate a  2 that looks up a table row given a primary key.  beam-coreRun a   in a  and get the results as a list  beam-coreRun a   in a  and get the unique result, if there is one. Both no results as well as more than one result cause this to return  .  beam-core9Use a special debug syntax to print out an ANSI Standard SELECT0 statement that may be generated for a given .  beam-core Generate a  $ over only certain fields of a table  beam-core Generate a  & given a table and a source of values.  beam-coreRun a   in a   beam-coreBuild a  % from series of expressions in tables  beam-coreBuild a   from concrete table values  beam-coreBuild a  4 from arbitrarily shaped data containing expressions  beam-coreBuild a   from a   that returns the same table  beam-coreBuild a  ? given a table, a list of assignments, and a way to build a WHERE clause.Use   for comparisons with .See the   operator for ways to build assignments. The argument to the second argument is a the table parameterized over , which represents the left hand side of assignments. Sometimes, you'd like to also get the current value of a particular column. You can use the   function to convert a  to a .  beam-coreBuild a  ? given a table, a list of assignments, and a way to build a WHERE clause.Uses a  comparison. Use   for comparisons with  .See the   operator for ways to build assignments. The argument to the second argument is a the table parameterized over , which represents the left hand side of assignments. Sometimes, you'd like to also get the current value of a particular column. You can use the   function to convert a  to a .  beam-coreA specialization of  / that matches the given (already existing) row.Use   for an internal  comparison.  beam-coreA specialization of  / that matches the given (already existing) row.Use   for an internal   comparison.  beam-coreA specialization of  + that is more convenient for normal tables.Use   for comparisons with .  beam-coreA specialization of  + that is more convenient for normal tables.Use   for comparisons with  .  beam-coreConvenience form of   that generates a WHERE7 clause that matches only the already existing entity.Use   for an internal  comparison.  beam-coreConvenience form of   that generates a WHERE7 clause that matches only the already existing entity.Uses   with a  comparison. Use   for an internal   comparison.  beam-core Use with   to set a field to an explicit new value that does not depend on any other value  beam-core Use with   to not modify the field  beam-core Use with   to set a field to a new value that is calculated based on one or more fields from the existing row  beam-core Use with   to optionally set a fiield to a new value, calculated based on one or more fields from the existing row  beam-core Generate a  ; that will update the given table row with the given value.The SQL UPDATE that is generated will set every non-primary key field for the row where each primary key field is exactly what is given.Note: This is a pure SQL UPDATE/ command. This does not upsert or merge values.Use   for an internal  comparison.  beam-core Generate a   that will update the given table row with the given value. This is a variant using   and a  comparison.The SQL UPDATE that is generated will set every non-primary key field for the row where each primary key field is exactly what is given.Note: This is a pure SQL UPDATE/ command. This does not upsert or merge values.Use   for an internal   comparison.  beam-coreRun a   in a .  beam-coreBuild a  # from a table and a way to build a WHERE clause  beam-coreRun a   in a   beam-coreTable to insert into beam-coreValues to insert. See  ,  ,  , and   for possibilities.  beam-coreTable to insert into beam-coreValues to insert. See  ,  , and   for possibilities.  beam-coreThe table to insert into beam-core"A sequence of assignments to make. beam-coreBuild a WHERE, clause given a table containing expressions  beam-coreThe table to insert into beam-core"A sequence of assignments to make. beam-coreBuild a WHERE, clause given a table containing expressions  beam-coreThe table to insert into beam-coreThe row to update beam-core"A sequence of assignments to make.  beam-coreThe table to insert into beam-coreThe row to update beam-core"A sequence of assignments to make.  beam-coreThe table to update beam-coreUpdates to be made (use   to construct an empty field)  beam-coreThe table to update beam-coreUpdates to be made (use   to construct an empty field)  beam-coreThe table to update beam-coreThe row to update beam-coreUpdates to be made (use   to construct an empty field)  beam-coreThe table to update beam-coreThe row to update beam-coreUpdates to be made (use   to construct an empty field)  beam-coreTable to update beam-coreValue to set to  beam-coreTable to update beam-coreValue to set to  beam-coreTable to delete from beam-coreBuild a WHERE, clause given a table containing expressions     None '(-/023589>?#'() '()None! '(-/023589>?  beam-coreSpecifies the kind of constraint that must be violated for the action to occur  beam-coreWhat to do when an INSERT( statement inserts a row into the table tbl that violates a constraint.  beam-cores that suppert returning rows that will be deleted by the given DELETE statement. Useful for deallocating resources based on the value of deleted rows.  beam-core0s that support returning the updated rows of an UPDATE statement. Useful for discovering the new values of the updated rows.  beam-core6s that support returning the newly created rows of an INSERT statement. Useful for discovering the real value of a defaulted value.   $%&$'($')$*+$*,$-.$')/0012233456789:;<=>?@ABCDEFGHIJKLMNOOPQRSTTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ! ! ! ! ! ! ! ! ! ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #                                                                                                $  $    $  $                    $   $  " " " (beam-core-0.9.1.0-DKWAhk16JQP4UstXx728dp Database.BeamDatabase.Beam.Schema.Tables%Database.Beam.Backend.Internal.CompatDatabase.Beam.Backend.SQL.TypesDatabase.Beam.Backend.TypesDatabase.Beam.Backend.SQL.RowDatabase.Beam.Backend.SQL.SQL92Database.Beam.Backend.SQL.SQL99!Database.Beam.Backend.SQL.SQL2003Database.Beam.Backend.SQL.ASTDatabase.Beam.Backend.SQL!Database.Beam.Backend.SQL.BuilderDatabase.Beam.Backend.URIDatabase.Beam.SchemaDatabase.Beam.Query.InternalDatabase.Beam.Query.SQL92Database.Beam.Query.TypesDatabase.Beam.QueryDatabase.Beam.Query.DataTypesDatabase.Beam.Query.CustomSQLDatabase.Beam.Query.CTEDatabase.Beam.Query.Adhoc(Database.Beam.Backend.SQL.BeamExtensionsQueryDatabase.Beam.Backend Data.FunctorComposeDatabase.Beam.Schema.LensesDatabase.Beam.Query.OperatorDatabase.Beam.Query.OrdDatabase.Beam.Query.ExtractDatabase.Beam.Query.Combinators!Database.Beam.Query.RelationshipsDatabase.Beam.Query.AggregateDatabase.Beam.Query.ExtensionsbaseData.Typeable.InternalTypeable GHC.GenericsGeneric:*:Control.Monad.IO.ClassliftIOMonadIOData.Functor.IdentityIdentityPreferExplicitSize SqlSerialunSerial SqlBitStringSqlNull$fToJSONSqlSerial$fFromJSONSqlSerial$fShowSqlSerial$fReadSqlSerial $fEqSqlSerial$fOrdSqlSerial$fNumSqlSerial$fIntegralSqlSerial$fRealSqlSerial$fEnumSqlSerial$fShowSqlBitString$fEqSqlBitString$fOrdSqlBitString$fEnumSqlBitString$fBitsSqlBitString $fShowSqlNull $fEqSqlNull $fOrdSqlNull$fBoundedSqlNull $fEnumSqlNullNullableExposed BeamBackendBackendFromFieldFromBackendRowfromBackendRow valuesNeededFromBackendRowMFromBackendRowF ParseOneFieldAlt FailParseWithBeamRowReadError brreColumn brreErrorColumnParseErrorColumnUnexpectedNullColumnNotEnoughColumnsColumnTypeMismatchColumnErrorInternalctmHaskellType ctmSQLType ctmMessage parseOneField peekField$fExceptionBeamRowReadError$fAlternativeFromBackendRowM$fMonadFailFromBackendRowM$fMonadFromBackendRowM$fFromBackendRowbeSqlSerial$fFromBackendRowbeTagged$fFromBackendRowbeMaybe$fFromBackendRowbeVector$fFromBackendRowbetbl$fFromBackendRowbetbl0$fFromBackendRowbe(,,,,,,,)$fFromBackendRowbe(,,,,,,)$fFromBackendRowbe(,,,,,)$fFromBackendRowbe(,,,,)$fFromBackendRowbe(,,,)$fFromBackendRowbe(,,)$fFromBackendRowbe(,)$fFromBackendRowbe()$fGFromBackendRowbeK1K1$fGFromBackendRowbeK1K10$fGFromBackendRowbeK1K11$fGFromBackendRowbe:*::*:$fGFromBackendRowbeeU1$fGFromBackendRowbeM1M1$fFunctorFromBackendRowM$fApplicativeFromBackendRowM$fShowBeamRowReadError$fEqBeamRowReadError$fOrdBeamRowReadError$fShowColumnParseError$fEqColumnParseError$fOrdColumnParseError$fGeneric(,,,,,,,)$fFunctorFromBackendRowFIsSql92FromOuterJoinSyntax outerJoinIsSql92FromSyntaxSql92FromTableSourceSyntaxSql92FromExpressionSyntax fromTable innerJoinleftJoin rightJoinIsSql92GroupingSyntaxSql92GroupingExpressionSyntaxgroupByExpressionsIsSql92TableSourceSyntaxSql92TableSourceSelectSyntax Sql92TableSourceExpressionSyntaxSql92TableSourceTableNameSyntax tableNamedtableFromSubSelecttableFromValuesIsSql92TableNameSyntax tableNameIsSql92OrderingSyntaxSql92OrderingExpressionSyntax ascOrdering descOrderingIsSql92ProjectionSyntaxSql92ProjectionExpressionSyntax projExprs%IsSql92AggregationSetQuantifierSyntaxsetQuantifierDistinctsetQuantifierAll"IsSql92AggregationExpressionSyntax#Sql92AggregationSetQuantifierSyntax countAllEcountEavgEmaxEminEsumEIsSql92ExpressionSyntaxSql92ExpressionQuantifierSyntaxSql92ExpressionValueSyntaxSql92ExpressionSelectSyntaxSql92ExpressionFieldNameSyntaxSql92ExpressionCastTargetSyntax!Sql92ExpressionExtractFieldSyntaxvalueErowEquantifierListE coalesceEcaseEfieldEbetweenEandEorEaddEsubEmulEdivElikeEmodE overlapsEnullIfE positionEeqEneqEltEgtEleEgeEeqMaybeE neqMaybeEcastEnotEnegateEisNullE isNotNullEisTrueE isNotTrueEisFalseE isNotFalseE isUnknownE isNotUnknownE charLengthE octetLengthE bitLengthElowerEupperEtrimEabsEextractEexistsEuniqueE subqueryEcurrentTimestampEdefaultEinEIsSql92DataTypeSyntax domainTypecharType varCharTypenationalCharTypenationalVarCharTypebitType varBitType numericType decimalTypeintType smallIntType floatType doubleTyperealTypedateTypetimeType timestampTypeIsSql92ExtractFieldSyntax secondsField minutesField hourFielddayField monthField yearFieldIsSql92QuantifierSyntaxquantifyOverAllquantifyOverAnyIsSql92FieldNameSyntaxqualifiedFieldunqualifiedFieldIsSql92DeleteSyntaxSql92DeleteTableNameSyntaxSql92DeleteExpressionSyntax deleteStmtdeleteSupportsAliasIsSql92UpdateSyntaxSql92UpdateTableNameSyntaxSql92UpdateFieldNameSyntaxSql92UpdateExpressionSyntax updateStmtIsSql92InsertValuesSyntax!Sql92InsertValuesExpressionSyntaxSql92InsertValuesSelectSyntaxinsertSqlExpressions insertFromSqlIsSql92InsertSyntaxSql92InsertValuesSyntaxSql92InsertTableNameSyntax insertStmtIsSql92SelectTableSyntaxSql92SelectTableSelectSyntax Sql92SelectTableExpressionSyntax Sql92SelectTableProjectionSyntaxSql92SelectTableFromSyntaxSql92SelectTableGroupingSyntax#Sql92SelectTableSetQuantifierSyntaxselectTableStmt unionTablesintersectTables exceptTableIsSql92SelectSyntaxSql92SelectSelectTableSyntaxSql92SelectOrderingSyntax selectStmt IsSql92SyntaxSql92SelectSyntaxSql92InsertSyntaxSql92UpdateSyntaxSql92DeleteSyntax selectCmd insertCmd updateCmd deleteCmdSql92DisplaySyntax displaySyntaxSql92ReasonableMarshallerSql92SanityCheckSql92SelectSanityCheckSql92HasValueSyntaxSql92ExtractFieldSyntaxSql92ExpressionSyntaxSql92ValueSyntaxSql92TableNameSyntaxSql92InsertExpressionSyntaxSql92SelectFromSyntaxSql92SelectGroupingSyntaxSql92SelectProjectionSyntaxSql92SelectExpressionSyntaxHasSqlValueSyntaxsqlValueSyntaxautoSqlValueSyntax$fHasSqlValueSyntaxvsTagged"$fHasSqlValueSyntaxsyntaxSqlSerial"IsSql99CommonTableExpressionSyntaxSql99CTESelectSyntaxcteSubquerySyntax1IsSql99RecursiveCommonTableExpressionSelectSyntaxwithRecursiveSyntax(IsSql99CommonTableExpressionSelectSyntaxSql99SelectCTESyntax withSyntaxIsSql99DataTypeSyntaxcharacterLargeObjectTypebinaryLargeObjectType booleanType arrayTyperowType"IsSql99AggregationExpressionSyntaxeveryEsomeEanyEIsSql99ConcatExpressionSyntaxconcatEIsSql99ExpressionSyntax distinctE similarToEinstanceFieldE refFieldEIsSql99FunctionExpressionSyntax functionCallE functionNameEIsSql99SelectSyntaxIsSql2008BigIntDataTypeSyntax bigIntType!IsSql2003NthValueExpressionSyntax nthValueE/IsSql2003FirstValueAndLastValueExpressionSyntax firstValueE lastValueE#IsSql2003LeadAndLagExpressionSyntaxleadElagEIsSql2003NtileExpressionSyntaxntileEQWindow6$fProjectibleWithPredicatecontextPredicatebe->QGenExpr/$fProjectibleWithPredicatecontextPredicatebe->t0$fProjectibleWithPredicatecontextPredicatebe->t0$fMonadQ$fApplicativeQ $fFunctorQ$fMonoidQAssignment$fSemigroupQAssignment $fShowQField $fEqQField $fOrdQField $fFunctorQFbuildSql92Query'0$fProjectibleWithPredicatecsyntaxresPreserveLeft HasQBuilder buildSqlQuery QExprToFieldQExprToIdentity$fHasQBuilderMockSqlBackendSqlBool&&.||.&&?.||?.like_ similarTo_not_sqlNot_div_mod_concat_SqlOrdQuantified<*.>*.<=*.>=*.SqlOrd<.>.<=.>=.HasTableEqualityHasSqlQuantifiedEqualityChecksqlQEqEsqlQNeqEHasSqlEqualityChecksqlEqEsqlNeqE sqlEqTriE sqlNeqTriESqlEqQuantified==*./=*.SqlEq==./=.==?./=?. HasSqlInTable inRowValuesESqlInin_ QQuantifiedsqlBool_isTrue_ isNotTrue_isFalse_ isNotFalse_ isUnknown_ isNotUnknown_ unknownAs_possiblyNullBool_fromPossiblyNullBool_allOf_allIn_anyOf_anyIn_between_ HasSqlDate HasSqlTimeextract_hour_minutes_seconds_year_month_day_cast_intsmallintbigintbinary varbinarydatecharvarcharnationalVarchar nationalChardoublenumeric timestamptz timestamptimebooleancharacterLargeObjectbinaryLargeObjectarray maybeTypeIsCustomExprFn customExpr_IsCustomSqlSyntaxCustomSqlSyntaxcustomExprSyntax renderSyntax valueExpr_agg_#$fIsCustomSqlSyntaxSqlSyntaxBuilder$fIsStringCustomSqlSnippet$fMonoidCustomSqlSnippet$fSemigroupCustomSqlSnippet$fIsCustomExprFn->->($fIsCustomExprFnCustomSqlSnippetQGenExpr$fIsStringCustomSqlSyntax$fMonoidCustomSqlSyntax$fSemigroupCustomSqlSyntax ReusableQ QAnyScopeWithrunWith Recursiveness Nonrecursive RecursivereusableForCTE selectingreuse$fSemigroupRecursiveness$fMonoidRecursiveness$fMonadFixWith $fMonadWith$fApplicativeWith $fFunctorWith NamedFieldAdhoc AdhocTable mkAdhocFieldtable_field_$fAdhoc(,,,,,,,)$fAdhoc(,,,,,,)$fAdhoc(,,,,,) $fAdhoc(,,,,) $fAdhoc(,,,) $fAdhoc(,,) $fAdhoc(,)$fAdhocNamedFieldSqlDeconstructMaybeisJust_ isNothing_maybe_QIfElseQIfCond SqlJustablejust_nothing_ SqlOrderable SqlValableval_SqlValableTableHaskellLiteralForQExpr<-.all_ allFromView_values_join_join_'perhaps_ outerJoin_ outerJoin_' leftJoin_ leftJoin_' subselect_guard_guard_'filter_filter_'related_ relatedBy_ relatedBy_' references_ references_'nub_limit_offset_exists_unique_ distinct_ subquery_ charLength_ octetLength_ bitLength_currentTimestamp_ position_lower_upper_trim_current_union_ unionAll_ intersect_ intersectAll_except_ exceptAll_as_default_ noBounds_ fromBound_bounds_ unbounded_nrows_ noPartition_noOrder_ partitionBy_orderPartitionBy_frame_over_ withWindow_orderBy_ nullsFirst_ nullsLast_asc_desc_then_then_'else_if_ ifThenElse_bool_ coalesce_ fromMaybe_<|>.ManyToManyThrough ManyToManyOneToManyOptional OneToMaybe OneToManyOneToOne oneToMany_ oneToOne_oneToManyOptional_ oneToMaybe_ manyToMany_manyToManyPassthrough_ QGroupablegroup_ aggregate_ allInGroup_distinctInGroup_allInGroupExplicitly_min_max_avg_sum_ countAll_count_ cumeDist_ percentRank_ denseRank_ rowNumber_rank_minOver_maxOver_avgOver_sumOver_ countOver_ everyOver_ someOver_anyOver_ filterWhere_ filterWhere_'every_some_any_ntile_lead1_lag1_lead_lag_leadWithDefault_lagWithDefault_ firstValue_ lastValue_ nthValue_ln_exp_sqrt_ceiling_floor_**.stddevPopOver_stddevSampOver_ varPopOver_ varSampOver_ stddevPop_ stddevSamp_varPop_varSamp_ covarPopOver_covarSampOver_ corrOver_regrSlopeOver_regrInterceptOver_regrCountOver_regrRSquaredOver_ regrAvgYOver_ regrAvgXOver_ regrSXXOver_ regrSYYOver_ regrSXYOver_ covarPop_ covarSamp_corr_ regrSlope_regrIntercept_ regrCount_ regrRSquared_ regrAvgY_ regrAvgX_regrSXX_regrSYY_regrSXY_ SqlDelete SqlUpdateSqlIdentityUpdateSqlInsertValuesSqlInsertValuesEmpty SqlInsertSqlInsertNoRows SqlSelect QExprTable QGenExprTable QBaseScopeselect selectWithlookup_runSelectReturningListrunSelectReturningOne dumpSqlSelect insertOnlyinsert runInsertinsertExpressions insertData insertFromupdateupdate' updateRow updateRow' updateTable'updateTableRowupdateTableRow'set setFieldsTo toNewValue toOldValuetoUpdatedValuetoUpdatedValueMaybesavesave' runUpdatedelete runDeleteBeamHasInsertOnConflictSqlConflictTargetSqlConflictActioninsertOnConflict anyConflictconflictingFieldsconflictingFieldsWhereonConflictDoNothingonConflictUpdateSetonConflictUpdateSetWhereMonadBeamDeleteReturningrunDeleteReturningListMonadBeamUpdateReturningrunUpdateReturningListMonadBeamInsertReturningrunInsertReturningListonConflictUpdateInsteadonConflictUpdateAll $fMonadBeamInsertReturningbeRWST!$fMonadBeamInsertReturningbeRWST0#$fMonadBeamInsertReturningbeWriterT$$fMonadBeamInsertReturningbeWriterT0"$fMonadBeamInsertReturningbeStateT#$fMonadBeamInsertReturningbeStateT0#$fMonadBeamInsertReturningbeReaderT!$fMonadBeamInsertReturningbeContT#$fMonadBeamInsertReturningbeExceptT $fMonadBeamUpdateReturningbeRWST!$fMonadBeamUpdateReturningbeRWST0#$fMonadBeamUpdateReturningbeWriterT$$fMonadBeamUpdateReturningbeWriterT0"$fMonadBeamUpdateReturningbeStateT#$fMonadBeamUpdateReturningbeStateT0#$fMonadBeamUpdateReturningbeReaderT!$fMonadBeamUpdateReturningbeContT#$fMonadBeamUpdateReturningbeExceptT $fMonadBeamDeleteReturningbeRWST!$fMonadBeamDeleteReturningbeRWST0#$fMonadBeamDeleteReturningbeWriterT$$fMonadBeamDeleteReturningbeWriterT0"$fMonadBeamDeleteReturningbeStateT#$fMonadBeamDeleteReturningbeStateT0#$fMonadBeamDeleteReturningbeReaderT!$fMonadBeamDeleteReturningbeContT#$fMonadBeamDeleteReturningbeExceptT"$fSemigroupInaccessibleQAssignment$fMonoidInaccessibleQAssignmentghc-prim GHC.TypesIntWordGHC.BaseString GHC.MaybeNothingbytestring-0.10.10.0 Data.ByteString.Builder.InternalBuilder text-1.2.3.2Data.Text.InternalTextMaybe Data.StringIsString DatabaseTable DatabaseViewDatabaseDomainTypedbTableSettings dbTableSchemadbTableOrigNamedbTableCurrentNamedbViewSettings dbViewSchemadbViewOrigNamedbViewCurrentNameBool$fSqlEqQGenExprtbl0$fSqlEqQGenExprQGenExpr,$fSqlEqQuantifiedQGenExprQQuantifiedQGenExprHasTableEqualityNullableData.ByteString.Internal ByteStringControl.Monad.FixMonadFixTrueGHC.RealIntegral$fQGroupabletbltbl$fQGroupabletbltbl0$fQGroupableQGenExprQGenExpr