diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,17 @@ # Revision history for sqlc-haskell +## 0.2.0.0 -- 2026-07-14 + +* Mustache-style naming templates for generated declarations. +* Per-column type overrides via the `overrides` option. +* The plugin is now also published as a WASM module, so it can be + used without installing the `sqlc-hs` executable locally. +* Support for `:copyfrom` queries. +* Binary type support for PostgreSQL (`bytea`). +* Fix binding of positional `?` parameters in generated `toRow` + instances (SQLite). +* Normalise column types to lowercase before builtin matching (SQLite). + ## 0.1.0.0 -- YYYY-mm-dd * First version. Released on an unsuspecting world. diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -4,36 +4,244 @@ It leverages [postgresql-simple](https://hackage.haskell.org/package/postgresql-simple), [mysql-simple](https://hackage.haskell.org/package/mysql-simple), and [sqlite-simple](https://hackage.haskell.org/package/sqlite-simple), generating a thin layer on top of these well-known libraries. -Use below configuation in your sqlc.yaml to use sqlc-hs. Refer to the [sqlc documentation]( -https://docs.sqlc.dev/en/latest/guides/plugins.html) for more information +## Installation +sqlc-hs can be used as a WASM plugin or as a process plugin. Refer to the +[sqlc documentation](https://docs.sqlc.dev/en/latest/guides/plugins.html) +for more information. + +### WASM plugin (recommended) + +Every [release](https://github.com/alexbiehl/sqlc-hs/releases) ships a +`sqlc-hs-.wasm` module. sqlc downloads and runs it for you — no +local installation required. Point your sqlc.yaml at the release asset and +its sha256: + ```yaml version: '2' plugins: - name: haskell + wasm: + url: https://github.com/alexbiehl/sqlc-hs/releases/download/v0.2.0.0/sqlc-hs-v0.2.0.0.wasm + sha256: +``` + +The release notes of each release contain this snippet with the correct +sha256 filled in — copy it from there. + +### Process plugin + +Alternatively, install the `sqlc-hs` executable (e.g. via +`cabal install sqlc-hs`), ensure it is on your PATH when invoking sqlc, and +configure it as a process plugin: + +```yaml +version: '2' +plugins: + - name: haskell process: cmd: sqlc-hs ``` +## Usage + Use the plugin for your schemas like so ```yaml - codegen: - - out: gen - plugin: haskell +sql: + - engine: postgresql + queries: query.sql + schema: schema.sql + codegen: + - out: gen + plugin: haskell + options: + cabal_package_name: your-package + cabal_package_version: 0.1.0.0 + haskell_module_prefix: Database.Queries + overrides: + - db_type: bytea + haskell_type: + package: bytestring + module: Data.ByteString + type: Data.ByteString.ByteString +``` + +## Overrides + +`overrides` is a **list** of mappings — each entry tells sqlc-hs to map a +database type (or a specific column) to a Haskell type of your choosing. They +take precedence over the built-in type mappings for the relevant engine. + +### Fields + +Each override accepts the following keys: + +| Key | Required | Description | +| -------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| `db_type` | no* | The fully qualified database type to match, e.g. `bytea`, `pg_catalog.int4`, `text`. Matched against the column type sqlc reports. | +| `haskell_type` | yes | The Haskell type to use. Either a single mapping (see below) or a list of mappings — additional entries declare extra package/module dependencies to import. | +| `column` | no* | Match a specific column: `column`, `table.column` or `schema.table.column`. The table part matches the table name or its query alias; a bare `column` also matches aliased expression outputs (e.g. `CAST(... AS TEXT) AS created_at`), which carry no table. | +| `engine` | no | Restrict the override to a specific engine (`postgresql`, `mysql`, or `sqlite`). Useful when one configuration targets multiple engines. | +| `nullable` | no | If `true`, only match columns that are nullable. If `false` or omitted, only match columns that are `NOT NULL`. | + +\* At least one of `db_type` or `column` must be given. When both are given, +both must match. + +A `haskell_type` mapping has three fields, all of which must be fully +qualified: + +| Key | Description | +| --------- | ---------------------------------------------------------------------------- | +| `package` | The cabal package providing the type, e.g. `bytestring`. Added as a dependency in the generated cabal file. | +| `module` | The module to import, e.g. `Data.ByteString`. | +| `type` | The fully qualified type name, e.g. `Data.ByteString.ByteString`. May be a composed type like `Data.Vector.Vector Data.Text.Text`. | + +### Examples + +Map every `bytea` column to a strict `ByteString`: + +```yaml +overrides: + - db_type: bytea + haskell_type: + package: bytestring + module: Data.ByteString + type: Data.ByteString.ByteString +``` + +Give `haskell_type` as a **list** when the type is composed from more than +one module: the first entry's `type` is what gets rendered, and every +entry's `package`/`module` is added as a cabal dependency and import. Here a +custom `x509_certificate` domain maps to `Binary ByteString`, which needs +both `postgresql-simple` and `bytestring`: + +```yaml +overrides: + - db_type: x509_certificate + haskell_type: + - type: Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString + - package: postgresql-simple + module: Database.PostgreSQL.Simple + - package: bytestring + module: Data.ByteString +``` + +Map a single column (`accounts.id`) to a custom `UserId` newtype: + +```yaml +overrides: + - column: accounts.id + haskell_type: + package: your-package + module: Your.Types + type: Your.Types.UserId +``` + +Type a computed/aliased query output that the engine can only describe as +`TEXT` — e.g. a normalized timestamp — as a proper `UTCTime` (the runtime +`FromField`/`FromRow` instances of your driver do the decoding): + +```yaml +overrides: + - column: last_error_at + haskell_type: + package: time + module: Data.Time + type: Data.Time.UTCTime +``` + +Apply different mappings depending on the engine: + +```yaml +overrides: + - db_type: jsonb + engine: postgresql + haskell_type: + package: aeson + module: Data.Aeson + type: Data.Aeson.Value + - db_type: json + engine: mysql + haskell_type: + package: aeson + module: Data.Aeson + type: Data.Aeson.Value +``` + +Override only nullable columns of a given type: + +```yaml +overrides: + - db_type: text + nullable: true + haskell_type: + package: text + module: Data.Text + type: GHC.Base.Maybe Data.Text.Text +``` + +## Naming + +`naming` customizes how the names of generated declarations are rendered, +using mustache-style `{{variable}}` templates. Every key is optional — an +omitted template falls back to the default, which reproduces sqlc-hs's +historical naming, so existing configurations keep generating byte-identical +code. + +```yaml +codegen: + - plugin: haskell + out: queries options: - cabal_package_name: your-package - cabal_package_version: 0.1.0.0 - haskell_module_prefix: Database.Queries - overrides: - db_type: bytea - haskell_type: - package: bytestring - module: Data.ByteString - type: Data.ByteString.ByteString + naming: + query: "run{{query}}" + params_constructor: "Mk{{query}}Args" + result_constructor: "{{query}}Row" + enum_constructor: "Enum_{{enum}}_{{value}}" + field: "{{column}}_of_{{table}}" ``` -Ensure that the sqlc-hs executable is on your PATH when invoking sqlc. +| Key | Default | Context variables | +| -------------------- | -------------------------- | -------------------------------------------------------------------- | +| `query` | `query_{{query}}` | `query` — the query's name | +| `params_constructor` | `Params_{{query}}` | `query` | +| `result_constructor` | `Result_{{query}}` | `query` | +| `enum_constructor` | `Enum_{{enum}}_{{value}}` | `enum` — the database type name; `value` — the enum value | +| `field` | `{{prefix}}{{column}}` | `column`, `table`, `table_alias`, `schema`, `prefix` (see below) | + +With that configuration, a `ListUsers` query over a `users` table renders as + +```haskell +runListUsers :: Query "ListUsers" "SELECT" + +data instance Params "ListUsers" = MkListUsersArgs + { age_of_ :: Data.Int.Int32 + } + +data instance Result "ListUsers" = ListUsersRow + { id_of_users :: !Data.Int.Int32, + name_of_users :: !Data.Text.Text + } +``` + +instead of the default `query_ListUsers` / `Params_ListUsers` / +`Result_ListUsers` with `users_id` / `users_name` fields. (Note `age_of_`: +the parameter has no table, so `{{table}}` rendered empty — see the +`naming-templates` golden test for the full output.) + +`prefix` is the historical field namespacing, precomputed so the default +template needs no conditionals: the query's table alias (or, failing that, +the table name) followed by `_` — and empty for table-less outputs such as +computed/aliased expressions. + +Templates support plain `{{variable}}` interpolation only (whitespace inside +the braces is ignored); unknown variables render as the empty string, like in +mustache. Rendered names are always fixed up to be valid Haskell identifiers: +characters that cannot appear in an identifier become `_`, functions and +fields get a lower-case first letter (or a leading `_` for digits), +constructors an upper-case one, and Haskell keywords used as field names are +suffixed with `'`. # (Re-)Generate proto files with proto-lens diff --git a/sqlc-hs.cabal b/sqlc-hs.cabal --- a/sqlc-hs.cabal +++ b/sqlc-hs.cabal @@ -1,6 +1,6 @@ cabal-version: 3.4 name: sqlc-hs -version: 0.1.0.1 +version: 0.2.0.0 -- synopsis: -- description: @@ -14,6 +14,10 @@ synopsis: Generate type-safe Haskell code from SQL via https://github.com/sqlc-dev/sqlc. +description: + A Haskell code generator plugin for sqlc, allowing you to generate idiomatic Haskell types and functions directly from your SQL queries. + It leverages postgresql-simple, mysql-simple, and sqlite-simple, generating a thin layer on top of these well-known libraries. + -- copyright: build-type: Simple extra-doc-files: CHANGELOG.md @@ -22,6 +26,7 @@ templates/internal.mysql.hs.jinja templates/internal.postgresql.hs.jinja templates/internal.sqlite.hs.jinja + templates/types.hs.jinja templates/package.cabal.jinja templates/query.hs.jinja templates/toplevel.hs.jinja @@ -76,6 +81,7 @@ Sqlc.Hs.Codegen Sqlc.Hs.Config Sqlc.Hs.Main + Sqlc.Hs.NameTemplate Sqlc.Hs.Resolve build-depends: diff --git a/src/Sqlc/Hs/Codegen.hs b/src/Sqlc/Hs/Codegen.hs --- a/src/Sqlc/Hs/Codegen.hs +++ b/src/Sqlc/Hs/Codegen.hs @@ -7,6 +7,7 @@ where import Data.FileEmbed qualified +import Data.List (lookup) import Data.ProtoLens.Labels () import Proto.Protos.Codegen qualified import Sqlc.Hs.Config (Config (..), HaskellType (..)) @@ -16,8 +17,13 @@ ResolvedNames (..), determineInternalModule, determineTopLevelModule, + determineTypesModule, + mangleQuery, + newEnumResolver, newResolveType, + queryParamBindings, resolveQueryName, + resolveType, ) import System.Exit qualified import System.IO qualified @@ -44,6 +50,28 @@ codegen :: Config -> Proto.Protos.Codegen.GenerateRequest -> IO [File] codegen config generateRequest = do + typesModule <- + codegenTypes + (generateRequest ^. #settings . #engine) + internalName + typesName + resolveName + (generateRequest ^. #catalog . #schemas) + + let resolveType = + newResolveType config (generateRequest ^. #settings . #engine) + <> newEnumResolver + ( HaskellType + { module' = Just typesModule.name, + package = Nothing, + name = Nothing + } + ) + [ enum + | schema <- generateRequest ^. #catalog . #schemas, + enum <- schema ^. #enums + ] + modules <- traverse ( codegenQuery @@ -55,24 +83,21 @@ (toList (generateRequest ^. #queries)) toplevelModule <- - codegenToplevel toplevelName internalName modules + codegenToplevel toplevelName internalName typesName modules internalModule <- codegenInternal (generateRequest ^. #settings . #engine) internalName let generatedModules = - toplevelModule : internalModule : modules + toplevelModule : typesModule : internalModule : modules cabalPackageFile <- codegenCabalFile config generatedModules pure (cabalPackageFile <> map moduleToFile generatedModules) where - resolveType = - newResolveType config (generateRequest ^. #settings . #engine) - resolveName = - resolveQueryName config.haskellModulePrefix + resolveQueryName config.naming config.haskellModulePrefix toplevelName = determineTopLevelModule config.haskellModulePrefix @@ -80,6 +105,9 @@ internalName = determineInternalModule config.haskellModulePrefix + typesName = + determineTypesModule config.haskellModulePrefix + moduleToFile :: Module -> File moduleToFile module_ = File @@ -92,13 +120,16 @@ ResolvedNames -> -- | ResolvedName of the internal module name ResolvedNames -> + -- | ResolvedName of the types module name + ResolvedNames -> [Module] -> IO Module -codegenToplevel toplevel internal modulesToReexport = do +codegenToplevel toplevel internal types modulesToReexport = do let context = Text.EDE.fromPairs [ "moduleName" Text.EDE..= toplevel.toHaskellModuleName, "internalModuleName" Text.EDE..= internal.toHaskellModuleName, + "typesModuleName" Text.EDE..= types.toHaskellModuleName, "modules" Text.EDE..= fmap (.name) modulesToReexport ] @@ -133,7 +164,10 @@ { name = internal.toHaskellModuleName, fileName = internal.toHaskellFileName, importedTypes = - [HaskellType {package = Just "base", module' = Nothing, name = Nothing}] + [ HaskellType {package = Just "base", module' = Nothing, name = Nothing}, + HaskellType {package = Just "bytestring", module' = Nothing, name = Nothing}, + HaskellType {package = Just "text", module' = Nothing, name = Nothing} + ] <> dependencies, contents = contents context } @@ -179,7 +213,8 @@ [ "packageName" Text.EDE..= packageName, "packageVersion" Text.EDE..= config.cabalPackageVersion, "buildDepends" Text.EDE..= buildDepends, - "exposedModules" Text.EDE..= exposedModules + "exposedModules" Text.EDE..= exposedModules, + "defaultExtensions" Text.EDE..= defaultExtensions ] pure [ File @@ -213,6 +248,62 @@ (.name) generatedModules + defaultExtensions :: [Text] + defaultExtensions = + sort (ordNub config.cabalDefaultExtensions) + +codegenTypes :: + -- | Engine, if defined + Text -> + -- | ResolvedName of the internal module + ResolvedNames -> + -- | ResolvedName of the types module + ResolvedNames -> + ResolveName -> + [Proto.Protos.Codegen.Schema] -> + IO Module +codegenTypes engine internalModule typesModule resolveName schemas = do + let context = + Text.EDE.fromPairs + [ "generatePostgresql" Text.EDE..= (engine == "postgresql"), + "generateSqlite" Text.EDE..= (engine == "sqlite"), + "generateMysql" Text.EDE..= (engine == "mysql"), + "moduleName" Text.EDE..= typesModule.toHaskellModuleName, + "internalModuleName" Text.EDE..= internalModule.toHaskellModuleName, + "enums" + Text.EDE..= [ Text.EDE.fromPairs + [ "escapedEnumName" Text.EDE..= show @Text (enum ^. #name), + "values" + Text.EDE..= [ Text.EDE.fromPairs + [ "escapedEnumValue" Text.EDE..= show @Text value, + "haskellConstructorName" Text.EDE..= (resolveName value).toEnumConstructorName (enum ^. #name) + ] + | value <- toList (enum ^. #vals) + ] + ] + | schema <- + schemas, + enum <- + schema ^. #enums, + (schema ^. #name) `notElem` ["pg_catalog", "information_schema"] + ] + ] + + pure + Module + { name = typesModule.toHaskellModuleName, + fileName = typesModule.toHaskellFileName, + importedTypes = [], + contents = contents context + } + where + contents context = + case Text.EDE.render typesTemplate context of + Text.EDE.Success output -> + encodeUtf8 (toStrict @LText @Text output) + Text.EDE.Failure errorDoc -> + error (show errorDoc) + -- | Generate a file for a single query. This returns the resolved 'HaskellType's so -- that we can generate the necessary build-depends for the cabal file. codegenQuery :: @@ -224,24 +315,28 @@ ResolveType -> Proto.Protos.Codegen.Query -> IO Module -codegenQuery engine internalModule resolveName resolveType query = do +codegenQuery engine internalModule resolveName resolver query = do let resolvedName = resolveName (query ^. #name) - parameterColumns <- + parameterColumns :: [(Int32, (Proto.Protos.Codegen.Column, NonEmpty HaskellType))] <- forM (query ^. #params) $ \parameter -> do - whenNothing (resolveType (parameter ^. #column)) $ - couldNotResolveType (parameter ^. #column) + parameterColumn <- + whenNothing (resolveType resolver (parameter ^. #column)) $ + couldNotResolveType (parameter ^. #column) + pure (parameter ^. #number, parameterColumn) resultColumns <- forM (query ^. #columns) $ \column -> do - whenNothing (resolveType column) $ + whenNothing (resolveType resolver column) $ couldNotResolveType column let importedTypes :: [HaskellType] importedTypes = - foldMap (toList . snd) parameterColumns + foldMap (toList . snd . snd) parameterColumns <> foldMap (toList . snd) resultColumns + <> [ HaskellType {package = Just "base", module' = Just "Data.Foldable", name = Nothing} + ] -- Modules that the query module needs to import. imports :: [Text] @@ -264,8 +359,9 @@ "haskellResultName" Text.EDE..= resolvedName.toResultConstructorDeclarationName, "escapedQueryName" Text.EDE..= show @Text (query ^. #name), "escapedCommand" Text.EDE..= show @Text (query ^. #cmd), - "escapedSql" Text.EDE..= show @Text (query ^. #text), - "parameterColumns" Text.EDE..= fmap toParameterColumn parameterColumns, + "escapedSql" Text.EDE..= show @Text mangledQuery, + "parameterColumns" Text.EDE..= fmap (toParameterColumn . snd) parameterColumns, + "queryColumns" Text.EDE..= fmap toParameterColumn (toQueryColumns parameterColumns), "resultColumns" Text.EDE..= fmap toResultColumn resultColumns ] @@ -277,6 +373,20 @@ contents = contents context } where + mangledQuery = + mangleQuery (query ^. #text) + + -- It's possible for parametes to appear in a query more than once. + -- This function "zips" the occurrences in the query with the actual + -- parameters. + toQueryColumns :: [(Int32, parameterColumn)] -> [parameterColumn] + toQueryColumns parameterColumns = + mapMaybe + ( \number -> + lookup (fromIntegral number) parameterColumns + ) + (queryParamBindings engine (query ^. #text)) + contents context = case Text.EDE.render queryTemplate context of Text.EDE.Success output -> @@ -286,13 +396,18 @@ toParameterColumn (column, haskellType :| _) = Text.EDE.fromPairs - [ "name" Text.EDE..= (resolveName (column ^. #name)).toFieldName, - "type" Text.EDE..= encodeColumnType haskellType + [ "name" Text.EDE..= (resolveName (column ^. #name)).toFieldName column, + "type" Text.EDE..= encodeColumnType haskellType, + "notNull" Text.EDE..= (column ^. #notNull), + "slice" + Text.EDE..= if column ^. #isSqlcSlice + then Just (show @Text ("/*SLICE:" <> column ^. #name <> "*/?")) + else Nothing ] toResultColumn (column, haskellType :| _) = Text.EDE.fromPairs - [ "name" Text.EDE..= (resolveName (column ^. #name)).toFieldName, + [ "name" Text.EDE..= (resolveName (column ^. #name)).toFieldName column, "type" Text.EDE..= encodeColumnType haskellType ] @@ -309,72 +424,36 @@ toplevelTemplate :: Text.EDE.Template toplevelTemplate = - case Text.EDE.parse template of - Text.EDE.Success template -> - template - Text.EDE.Failure errorDoc -> - error (show errorDoc) - where - template :: ByteString - template = - $(Data.FileEmbed.embedFile "templates/toplevel.hs.jinja") + toTemplate $(Data.FileEmbed.embedFile "templates/toplevel.hs.jinja") queryTemplate :: Text.EDE.Template queryTemplate = - case Text.EDE.parse template of - Text.EDE.Success template -> - template - Text.EDE.Failure errorDoc -> - error (show errorDoc) - where - template :: ByteString - template = - $(Data.FileEmbed.embedFile "templates/query.hs.jinja") + toTemplate $(Data.FileEmbed.embedFile "templates/query.hs.jinja") +typesTemplate :: Text.EDE.Template +typesTemplate = + toTemplate $(Data.FileEmbed.embedFile "templates/types.hs.jinja") + internalPostgresTemplate :: Text.EDE.Template internalPostgresTemplate = - case Text.EDE.parse template of - Text.EDE.Success template -> - template - Text.EDE.Failure errorDoc -> - error (show errorDoc) - where - template :: ByteString - template = - $(Data.FileEmbed.embedFile "templates/internal.postgresql.hs.jinja") + toTemplate $(Data.FileEmbed.embedFile "templates/internal.postgresql.hs.jinja") internalMysqlTemplate :: Text.EDE.Template internalMysqlTemplate = - case Text.EDE.parse template of - Text.EDE.Success template -> - template - Text.EDE.Failure errorDoc -> - error (show errorDoc) - where - template :: ByteString - template = - $(Data.FileEmbed.embedFile "templates/internal.mysql.hs.jinja") + toTemplate $(Data.FileEmbed.embedFile "templates/internal.mysql.hs.jinja") internalSqliteTemplate :: Text.EDE.Template internalSqliteTemplate = - case Text.EDE.parse template of - Text.EDE.Success template -> - template - Text.EDE.Failure errorDoc -> - error (show errorDoc) - where - template :: ByteString - template = - $(Data.FileEmbed.embedFile "templates/internal.sqlite.hs.jinja") + toTemplate $(Data.FileEmbed.embedFile "templates/internal.sqlite.hs.jinja") cabalTemplate :: Text.EDE.Template cabalTemplate = + toTemplate $(Data.FileEmbed.embedFile "templates/package.cabal.jinja") + +toTemplate :: ByteString -> Text.EDE.Template +toTemplate template = do case Text.EDE.parse template of Text.EDE.Success template -> template Text.EDE.Failure errorDoc -> error (show errorDoc) - where - template :: ByteString - template = - $(Data.FileEmbed.embedFile "templates/package.cabal.jinja") diff --git a/src/Sqlc/Hs/Config.hs b/src/Sqlc/Hs/Config.hs --- a/src/Sqlc/Hs/Config.hs +++ b/src/Sqlc/Hs/Config.hs @@ -2,6 +2,7 @@ ( Config (..), Override (..), HaskellType (..), + Naming (..), parseConfig, defaultConfig, ) @@ -24,11 +25,15 @@ cabalPackageName :: Maybe Text, -- | Package version to be used with the cabal package. cabalPackageVersion :: Maybe Text, + -- | Default extensions that will be placed in the default-extension stanza + cabalDefaultExtensions :: [Text], -- | Module prefix, e.g. Data.Queries haskellModulePrefix :: Maybe Text, -- | List of lists of overrides. Nesting is list of allowing cheap -- concatenation. No need to create a one big vector. - overrides :: [Vector Override] + overrides :: [Vector Override], + -- | Templates for the names of generated declarations. + naming :: Naming } instance Semigroup Config where @@ -40,8 +45,12 @@ getFirst $ First config1.cabalPackageVersion <> First config2.cabalPackageVersion, haskellModulePrefix = getFirst $ First config1.haskellModulePrefix <> First config2.haskellModulePrefix, + cabalDefaultExtensions = + config1.cabalDefaultExtensions <> config2.cabalDefaultExtensions, overrides = - config1.overrides <> config2.overrides + config1.overrides <> config2.overrides, + naming = + config1.naming <> config2.naming } instance Monoid Config where @@ -50,7 +59,9 @@ { overrides = [], haskellModulePrefix = Nothing, cabalPackageName = Nothing, - cabalPackageVersion = Nothing + cabalPackageVersion = Nothing, + cabalDefaultExtensions = [], + naming = mempty } instance FromJSON Config where @@ -58,13 +69,76 @@ Config <$> o .:? "cabal_package_name" <*> o .:? "cabal_package_version" + <*> o .:? "cabal_default_extensions" .!= [] <*> o .:? "haskell_module_prefix" <*> fmap pure (o .:? "overrides" .!= mempty) + <*> o .:? "naming" .!= mempty +-- | Mustache-style templates for the names of generated declarations. Every +-- field is optional; an omitted template falls back to the default that +-- reproduces sqlc-hs's historical naming, so existing configurations generate +-- byte-identical code. +-- +-- See the README for the variables available to each template. +data Naming = Naming + { -- | Query declaration, default @query_{{query}}@. Context: @query@. + query :: Maybe Text, + -- | Params constructor, default @Params_{{query}}@. Context: @query@. + paramsConstructor :: Maybe Text, + -- | Result constructor, default @Result_{{query}}@. Context: @query@. + resultConstructor :: Maybe Text, + -- | Enum value constructor, default @Enum_{{enum}}_{{value}}@. Context: + -- @enum@ (the database type name), @value@ (the enum value). + enumConstructor :: Maybe Text, + -- | Record field, default @{{prefix}}{{column}}@. Context: @column@, + -- @table@, @table_alias@, @schema@ and @prefix@ (the historical + -- namespacing: the table alias or table name followed by @_@, empty for + -- table-less expression outputs). + field :: Maybe Text + } + +instance Semigroup Naming where + naming1 <> naming2 = + Naming + { query = + getFirst $ First naming1.query <> First naming2.query, + paramsConstructor = + getFirst $ First naming1.paramsConstructor <> First naming2.paramsConstructor, + resultConstructor = + getFirst $ First naming1.resultConstructor <> First naming2.resultConstructor, + enumConstructor = + getFirst $ First naming1.enumConstructor <> First naming2.enumConstructor, + field = + getFirst $ First naming1.field <> First naming2.field + } + +instance Monoid Naming where + mempty = + Naming + { query = Nothing, + paramsConstructor = Nothing, + resultConstructor = Nothing, + enumConstructor = Nothing, + field = Nothing + } + +instance FromJSON Naming where + parseJSON = withObject "Naming" $ \o -> + Naming + <$> o .:? "query" + <*> o .:? "params_constructor" + <*> o .:? "result_constructor" + <*> o .:? "enum_constructor" + <*> o .:? "field" + data Override = Override - { haskellType :: HaskellType, - databaseType :: Text, - -- Fully qualified name of the column, e.g. `accounts.id` + { haskellType :: NonEmpty HaskellType, + -- | Database type to match, e.g. @text@. Optional when 'column' is given. + databaseType :: Maybe Text, + -- | Column to match: @column@, @table.column@ or @schema.table.column@. + -- A bare @column@ also matches aliased expression outputs, which carry no + -- table. Optional when 'databaseType' is given; when both are given, both + -- must match. column :: Maybe Text, -- | For global overrides only when two different engines are in use. engine :: Maybe Text, @@ -73,13 +147,22 @@ } instance FromJSON Override where - parseJSON = withObject "Override" $ \o -> - Override - <$> o .: "haskell_type" - <*> o .: "db_type" - <*> o .:? "column" - <*> o .:? "engine" - <*> o .:? "nullable" + parseJSON = withObject "Override" $ \o -> do + override <- + Override + <$> ( -- We allow multiple haskell-types per database type + -- to support composite types and their dependencies. + fmap pure (o .: "haskell_type") + <|> o + .: "haskell_type" + ) + <*> o .:? "db_type" + <*> o .:? "column" + <*> o .:? "engine" + <*> o .:? "nullable" + when (isNothing override.databaseType && isNothing override.column) $ + fail "override requires at least one of \"db_type\" or \"column\"" + pure override -- | A haskell type denotes a fully qualified data type with module -- and import and all. @@ -105,9 +188,9 @@ instance FromJSON HaskellType where parseJSON = withObject "HaskellType" $ \o -> HaskellType - <$> fmap Just (o .: "package") - <*> fmap Just (o .: "module") - <*> fmap Just (o .: "type") + <$> o .:? "package" + <*> o .:? "module" + <*> o .:? "type" parseConfig :: ByteString -> Either String Config parseConfig input = @@ -120,6 +203,7 @@ mempty { cabalPackageName = Just "queries", cabalPackageVersion = Just "0.1.0.0", + cabalDefaultExtensions = [], haskellModulePrefix = Just "Queries", overrides = [] } diff --git a/src/Sqlc/Hs/Main.hs b/src/Sqlc/Hs/Main.hs --- a/src/Sqlc/Hs/Main.hs +++ b/src/Sqlc/Hs/Main.hs @@ -31,7 +31,7 @@ Right generateRequest -> pure generateRequest - -- System.IO.hPutStrLn System.IO.stdout (show $ generateRequest) + -- System.IO.hPutStrLn System.IO.stdout (show $ generateRequest) pluginOptions <- case Sqlc.Hs.Config.parseConfig (generateRequest ^. #pluginOptions) of diff --git a/src/Sqlc/Hs/NameTemplate.hs b/src/Sqlc/Hs/NameTemplate.hs new file mode 100644 --- /dev/null +++ b/src/Sqlc/Hs/NameTemplate.hs @@ -0,0 +1,40 @@ +-- | Minimal mustache-style template rendering for generated-code names. +-- +-- Supports exactly one construct: @{{variable}}@ (whitespace inside the +-- braces is ignored), replaced by the variable's value from the context. +-- Unknown variables render as the empty string, mirroring mustache's +-- behaviour. There are deliberately no sections, no escaping and no nested +-- lookups — names are short and the conditional cases (e.g. the table prefix +-- of a field name) are precomputed into context variables instead. +module Sqlc.Hs.NameTemplate + ( render, + ) +where + +import Data.List qualified +import Data.Text qualified + +-- | @render context template@ substitutes every @{{var}}@ in @template@ with +-- its value from @context@. +-- +-- >>> render [("query", "ListUsers")] "query_{{query}}" +-- "query_ListUsers" +render :: [(Text, Text)] -> Text -> Text +render context = go + where + go template = + case Data.Text.breakOn "{{" template of + (before, "") -> + before + (before, rest) -> + case Data.Text.breakOn "}}" (Data.Text.drop 2 rest) of + -- Unterminated "{{": emit it verbatim. + (_, "") -> + before <> Data.Text.take 2 rest <> go (Data.Text.drop 2 rest) + (variable, closed) -> + before + <> lookupVariable (Data.Text.strip variable) + <> go (Data.Text.drop 2 closed) + + lookupVariable variable = + fromMaybe "" (Data.List.lookup variable context) diff --git a/src/Sqlc/Hs/Resolve.hs b/src/Sqlc/Hs/Resolve.hs --- a/src/Sqlc/Hs/Resolve.hs +++ b/src/Sqlc/Hs/Resolve.hs @@ -1,6 +1,8 @@ module Sqlc.Hs.Resolve ( ResolveType, + resolveType, newResolveType, + newEnumResolver, -- | How to resolve names to Haskell modules and files ResolveName, ResolvedNames (..), @@ -8,6 +10,10 @@ -- | Misc. modules determineTopLevelModule, determineInternalModule, + determineTypesModule, + -- | Query mangling + mangleQuery, + queryParamBindings, ) where @@ -17,7 +23,8 @@ import Data.Text qualified import Data.Vector (Vector) import Proto.Protos.Codegen qualified -import Sqlc.Hs.Config (Config (..), HaskellType (..), Override (..), defaultConfig) +import Sqlc.Hs.Config (Config (..), HaskellType (..), Naming (..), Override (..), defaultConfig) +import Sqlc.Hs.NameTemplate qualified import System.FilePath ((<.>)) determineTopLevelModule :: @@ -26,6 +33,7 @@ ResolvedNames determineTopLevelModule haskellModulePrefix = resolveQueryName + mempty Nothing (fromMaybe "Queries" (haskellModulePrefix <|> defaultConfig.haskellModulePrefix)) @@ -35,27 +43,41 @@ ResolvedNames determineInternalModule haskellModulePrefix = resolveQueryName + mempty (haskellModulePrefix <|> defaultConfig.haskellModulePrefix <|> Just "Queries") "Internal" +determineTypesModule :: + -- | Haskell module prefix. E.g. "Data.Queries". + Maybe Text -> + ResolvedNames +determineTypesModule haskellModulePrefix = + resolveQueryName + mempty + (haskellModulePrefix <|> defaultConfig.haskellModulePrefix <|> Just "Queries") + "Types" + data ResolvedNames = ResolvedNames { toQueryDeclarationName :: Text, toParamsConstructorDeclarationName :: Text, toResultConstructorDeclarationName :: Text, toHaskellFileName :: Text, toHaskellModuleName :: Text, - toFieldName :: Text + toFieldName :: Proto.Protos.Codegen.Column -> Text, + toEnumConstructorName :: Text -> Text } type ResolveName = Text -> ResolvedNames resolveQueryName :: + -- | Name templates. 'mempty' renders the historical names. + Naming -> -- | Haskell module prefix. E.g. "Data.Queries". Maybe Text -> -- | Name to resolve Text -> ResolvedNames -resolveQueryName haskellModulePrefix name = +resolveQueryName naming haskellModulePrefix name = ResolvedNames { toQueryDeclarationName = -- This generates @@ -63,14 +85,20 @@ -- query_GetAuthors :: ... -- -- in the query modules. - -- - -- We could some more sophisticated things to make the query name a valid haskell function - -- declaration identifier. - "query_" <> sanitizedName, + asVariableName $ + renderName naming.query "query_{{query}}" [("query", name)], toParamsConstructorDeclarationName = - "Params_" <> sanitizedName, + asConstructorName $ + renderName naming.paramsConstructor "Params_{{query}}" [("query", name)], toResultConstructorDeclarationName = - "Result_" <> sanitizedName, + asConstructorName $ + renderName naming.resultConstructor "Result_{{query}}" [("query", name)], + toEnumConstructorName = \typename -> + asConstructorName $ + renderName + naming.enumConstructor + "Enum_{{enum}}_{{value}}" + [("enum", typename), ("value", name)], toFieldName, toHaskellFileName = toText $ @@ -96,10 +124,43 @@ Nothing -> identity - -- A version of the name suitable for consumption as a Haskell identifier. - sanitizedName :: Text - sanitizedName = sanitizeHaskellIdentifier name + -- Render a name template against its context: the configured template if + -- present, the default (historical) template otherwise. + renderName :: Maybe Text -> Text -> [(Text, Text)] -> Text + renderName template fallback context = + Sqlc.Hs.NameTemplate.render context (fromMaybe fallback template) + -- Rendered names must come out as valid Haskell identifiers regardless of + -- the template: sanitize the characters, then fix up the first character + -- for the identifier flavour. Both are identities on the names the + -- default templates render. + asVariableName :: Text -> Text + asVariableName rendered = + case Data.Text.uncons (sanitizeHaskellIdentifier rendered) of + Nothing -> + "_" + Just (c, rest) + | Data.Char.isDigit c -> + "_" <> Data.Text.cons c rest + | Data.Char.isUpper c -> + Data.Char.toLower c `Data.Text.cons` rest + | otherwise -> + Data.Text.cons c rest + + asConstructorName :: Text -> Text + asConstructorName rendered = + case Data.Text.uncons (sanitizeHaskellIdentifier rendered) of + Nothing -> + "C" + Just (c, rest) + | Data.Char.isLower c -> + Data.Char.toUpper c `Data.Text.cons` rest + | Data.Char.isUpper c -> + Data.Text.cons c rest + | otherwise -> + -- Digits and underscores cannot start a constructor. + "C" <> Data.Text.cons c rest + -- A version of the name suitable for use as a Haskell module name. sanitizedModuleName :: Text sanitizedModuleName = @@ -128,10 +189,10 @@ '_' ) - toFieldName :: Text - toFieldName = + toFieldName :: Proto.Protos.Codegen.Column -> Text + toFieldName column = escapeHaskellKeyword $ - case name of + case rendered of name | Just (c, _rest) <- Data.Text.uncons name, Data.Char.isDigit c -> @@ -143,7 +204,29 @@ Data.Char.toLower c `Data.Text.cons` rest | otherwise -> name + where + rendered = + renderName + naming.field + "{{prefix}}{{column}}" + [ ("column", name), + ("table", column ^. #table . #name), + ("table_alias", column ^. #tableAlias), + ("schema", column ^. #table . #schema), + ("prefix", prefix) + ] + -- The historical namespacing, precomputed so the default template + -- needs no conditionals: table alias or table name plus "_", empty + -- for table-less (expression) outputs. + prefix + | column ^. #tableAlias /= "" = + column ^. #tableAlias <> "_" + | column ^. #table . #name /= "" = + column ^. #table . #name <> "_" + | otherwise = + "" + escapeHaskellKeyword x = case x of "type" -> "type'" @@ -161,17 +244,25 @@ -- -- The first type is the one you want use for code generation while the rest is only info for dependency -- and import management. -type ResolveType = Proto.Protos.Codegen.Column -> Maybe (Proto.Protos.Codegen.Column, NonEmpty HaskellType) +newtype ResolveType = ResolveType (Proto.Protos.Codegen.Column -> Maybe (Proto.Protos.Codegen.Column, NonEmpty HaskellType)) +instance Semigroup ResolveType where + ResolveType resolve1 <> ResolveType resolve2 = + ResolveType $ \column -> + resolve1 column <|> resolve2 column + newtype Overrides a = Overrides [Vector a] deriving stock (Functor, Foldable, Traversable) +resolveType :: ResolveType -> Proto.Protos.Codegen.Column -> Maybe (Proto.Protos.Codegen.Column, NonEmpty HaskellType) +resolveType = coerce + newResolveType :: Config -> -- | Engine, if defined Text -> ResolveType -newResolveType config engine = \column -> +newResolveType config engine = ResolveType $ \column -> case mapMaybe (\matcher -> matcher.matcher column) matchers of haskellTypes : _ -> Just (column, haskellTypes) @@ -194,6 +285,17 @@ || matcher.engine == Just engine ] +newEnumResolver :: + HaskellType -> + [Proto.Protos.Codegen.Enum] -> + ResolveType +newEnumResolver typeTemplate enums = ResolveType $ \column -> + case (enumMatcher typeTemplate enums).matcher column of + Just haskellTypes -> + Just (column, haskellTypes) + _ -> + Nothing + columnDataType :: Proto.Protos.Codegen.Identifier -> Text columnDataType identifier | (identifier ^. #schema) /= mempty = @@ -205,16 +307,90 @@ overrideToMatcher override = Matcher { engine = override.engine, - matcher + matcher = \column -> + applyArrayLike + column + (if column ^. #notNull then identity else wrapMaybe) + $ wrap + $ matchType column } where - -- TODO extend the matching to support overriding individual columns - matcher column - | columnDataType (column ^. #type') == override.databaseType = - Just (pure override.haskellType) + wrap :: Maybe (NonEmpty HaskellType) -> Maybe (NonEmpty HaskellType) + wrap haskellTypes = + haskellTypes <&> \(haskellType :| haskellTypes) -> + haskellType {name = fmap wrapParenthesis haskellType.name} + :| haskellTypes + + -- Every constraint present on the override must hold: db_type (if given) + -- and column (if given). The FromJSON instance guarantees at least one of + -- the two is set, so this can never match unconditionally. + matchType column + | fromMaybe False override.nullable /= not (column ^. #notNull) = + Nothing + | matchesDatabaseType column, + matchesColumn column = + Just override.haskellType | otherwise = Nothing + matchesDatabaseType column = + case override.databaseType of + Nothing -> True + Just databaseType -> columnDataType (column ^. #type') == databaseType + + matchesColumn column = + case override.column of + Nothing -> True + Just name -> columnMatches name column + +-- | Match a column against a possibly qualified override name: @column@, +-- @table.column@ or @schema.table.column@. The table part matches the table's +-- name or its query alias. A bare @column@ also matches aliased expression +-- outputs (e.g. @CAST(... AS TEXT) AS created_at@), which carry no table. +columnMatches :: Text -> Proto.Protos.Codegen.Column -> Bool +columnMatches qualified column = + case reverse (Data.Text.splitOn "." qualified) of + [name] -> + nameMatches name + [name, table] -> + nameMatches name && tableMatches table + [name, table, schema] -> + nameMatches name && tableMatches table && column ^. #table . #schema == schema + _ -> + False + where + nameMatches name = + column ^. #name == name + + tableMatches table = + column ^. #table . #name == table || column ^. #tableAlias == table + +enumMatcher :: + -- | HaskellType pointing to the types module. + HaskellType -> + [Proto.Protos.Codegen.Enum] -> + Matcher +enumMatcher typeTemplate enums = + Matcher + { engine = Nothing, + matcher = \column -> + applyNullable column $ + applyArrayLike column identity $ + case find + (\enum -> (enum ^. #name) == columnDataType (column ^. #type')) + enums of + Just enum -> + Just $ + pure + typeTemplate + { name = + typeTemplate.module' <&> \module' -> + "(" <> module' <> "." <> "Enum " <> show @Text (enum ^. #name) <> ")" + } + Nothing -> + Nothing + } + builtins :: [Matcher] builtins = [ Matcher {engine = Just "postgresql", matcher = postgresBuiltin}, @@ -356,33 +532,80 @@ applyNullable :: Proto.Protos.Codegen.Column -> Maybe (NonEmpty HaskellType) -> Maybe (NonEmpty HaskellType) applyNullable column types | not (column ^. #notNull) = - case types of - Just types -> - Just $ - HaskellType - { package = Nothing, - module' = Nothing, - name = Just ("(GHC.Base.Maybe " <> fromMaybe "" (head types).name <> ")") - } - :| head types - : HaskellType - { package = Just "base", - module' = Just "GHC.Base", - name = Nothing - } - : tail types - Nothing -> - Nothing + fmap wrapMaybe types | otherwise = types +applyArrayLike :: + Proto.Protos.Codegen.Column -> + (NonEmpty HaskellType -> NonEmpty HaskellType) -> + Maybe (NonEmpty HaskellType) -> + Maybe (NonEmpty HaskellType) +applyArrayLike column wrapArrayLike haskellTypes + | Just haskellTypes <- haskellTypes, + column ^. #isArray = + Just (wrapArrayLike (wrapVector haskellTypes)) + | Just haskellTypes <- haskellTypes, + column ^. #isSqlcSlice = + Just (wrapList haskellTypes) + | otherwise = haskellTypes + +wrapVector :: NonEmpty HaskellType -> NonEmpty HaskellType +wrapVector (haskellType :| rest) = + haskellType + { name = + haskellType.name <&> \name -> + "Data.Vector.Vector " <> wrapParenthesis name + } + :| (vectorType : rest) + where + vectorType = + HaskellType + { name = Just "Data.Vector.Vector", + module' = Just "Data.Vector", + package = Just "vector" + } + +wrapList :: NonEmpty HaskellType -> NonEmpty HaskellType +wrapList (haskellType :| rest) = + haskellType + { name = + haskellType.name <&> \name -> + Data.Text.singleton '[' <> name <> Data.Text.singleton ']' + } + :| rest + +wrapMaybe :: NonEmpty HaskellType -> NonEmpty HaskellType +wrapMaybe (haskellType :| rest) = + HaskellType + { package = Nothing, + module' = Nothing, + name = + haskellType.name <&> \name -> + "GHC.Base.Maybe " <> wrapParenthesis name + } + :| haskellType + : HaskellType + { package = Just "base", + module' = Just "GHC.Base", + name = Nothing + } + : rest + +wrapParenthesis :: Text -> Text +wrapParenthesis input + | ' ' `Data.Text.elem` input = + Data.Text.singleton '(' <> input <> Data.Text.singleton ')' + | otherwise = + input + sqliteBuiltin :: Proto.Protos.Codegen.Column -> Maybe (NonEmpty HaskellType) sqliteBuiltin column = applyNullable column $ asum [ do guard $ - columnType `elem` ["int", "integer", "tinyint", "smallint", "mediumint", "bigint", "unsignedbigint", "int2", "int8"] + columnType `elem` ["int", "integer", "tinyint", "smallint", "mediumint", "bigint", "unsignedbigint", "int2", "int8"] if column ^. #unsigned then Just $ @@ -400,51 +623,53 @@ module' = Just "Data.Int", name = Just "Data.Int.Int64" }, - sqliteType ["blob"] "bytestring" "Data.ByteString.ByteString", sqliteType ["real", "double", "doubleprecision", "float"] "ghc-prim" "GHC.Types.Double", sqliteType ["bool", "boolean"] "ghc-prim" "GHC.Types.Bool", sqliteType ["date", "datetime", "timestamp"] "time" "Data.Time.UTCTime", - do guard $ - or [ - "character" `Data.Text.isPrefixOf` columnType, - "varchar" `Data.Text.isPrefixOf` columnType, - "varyingcharacter" `Data.Text.isPrefixOf` columnType, - "nchar" `Data.Text.isPrefixOf` columnType, - "nativecharacter" `Data.Text.isPrefixOf` columnType, - "nvarchar" `Data.Text.isPrefixOf` columnType, - columnType `elem` [ - "text", - "clob" + or + [ "character" `Data.Text.isPrefixOf` columnType, + "varchar" `Data.Text.isPrefixOf` columnType, + "varyingcharacter" `Data.Text.isPrefixOf` columnType, + "nchar" `Data.Text.isPrefixOf` columnType, + "nativecharacter" `Data.Text.isPrefixOf` columnType, + "nvarchar" `Data.Text.isPrefixOf` columnType, + columnType + `elem` [ "text", + "clob" + ] ] - ] Just $ - pure - HaskellType - { package = Just "text", - module' = Just "Data.Text", - name = Just "Data.Text.Text" - }, + pure + HaskellType + { package = Just "text", + module' = Just "Data.Text", + name = Just "Data.Text.Text" + }, do guard $ - or [ - "decimal" `Data.Text.isPrefixOf` columnType, - columnType == "numeric" - ] + or + [ "decimal" `Data.Text.isPrefixOf` columnType, + columnType == "numeric" + ] Just $ - pure - HaskellType - { package = Just "ghc-prim", - module' = Just "GHC.Types", - name = Just "GHC.Types.Double" - } + pure + HaskellType + { package = Just "ghc-prim", + module' = Just "GHC.Types", + name = Just "GHC.Types.Double" + } ] where + -- SQLite preserves the column type's casing exactly as written in the DDL + -- (e.g. @TEXT@, @Integer@), whereas the builtin matchers above compare + -- against lowercase names. Normalise to lowercase so type affinity is + -- recognised regardless of how the schema spells the type. columnType :: Text columnType = - columnDataType (column ^. #type') + Data.Text.toLower (columnDataType (column ^. #type')) sqliteType dbType package qualifiedType | columnType `elem` dbType = @@ -465,22 +690,23 @@ postgresBuiltin :: Proto.Protos.Codegen.Column -> Maybe (NonEmpty HaskellType) postgresBuiltin column = applyNullable column $ - asum - [ pgType ["serial", "serial4", "pg_catalog.serial4"] "base" "Data.Int.Int32", - pgType ["bigserial", "serial8", "pg_catalog.serial8"] "base" "Data.Int.Int64", - pgType ["smallserial", "serial2", "pg_catalog.serial2"] "base" "Data.Int.Int16", - pgType ["integer", "int", "int4", "pg_catalog.int4"] "base" "Data.Int.Int32", - pgType ["bigint", "int8", "pg_catalog.int8"] "base" "Data.Int.Int64", - pgType ["smallint", "int2", "pg_catalog.int2"] "base" "Data.Int.Int16", - pgType ["float", "double precision", "float8", "pg_catalog.float8"] "ghc-prim" "GHC.Types.Double", - pgType ["real", "float4", "pg_catalog.float4"] "ghc-prim" "GHC.Types.Float", - pgType ["numeric", "pg_catalog.numeric", "money"] "scientific" "Data.Scientific.Scientific", - pgType ["boolean", "bool", "pg_catalog.bool"] "ghc-prim" "GHC.Types.Bool", - pgType ["json", "pg_catalog.json"] "aeson" "Data.Aeson.Value", - pgType ["jsonb", "pg_catalog.jsonb"] "aeson" "Data.Aeson.Value", - pgType ["bytea", "blob", "pg_catalog.bytea"] "bytestring" "Data.ByteString.Short.ShortByteString", - pgType ["text", "pg_catalog.varchar", "pg_catalog.bpchar", "string", "citext", "name"] "text" "Data.Text.Text" - ] + applyArrayLike column identity $ + asum + [ pgType ["serial", "serial4", "pg_catalog.serial4"] "base" "Data.Int.Int32", + pgType ["bigserial", "serial8", "pg_catalog.serial8"] "base" "Data.Int.Int64", + pgType ["smallserial", "serial2", "pg_catalog.serial2"] "base" "Data.Int.Int16", + pgType ["integer", "int", "int4", "pg_catalog.int4"] "base" "Data.Int.Int32", + pgType ["bigint", "int8", "pg_catalog.int8"] "base" "Data.Int.Int64", + pgType ["smallint", "int2", "pg_catalog.int2"] "base" "Data.Int.Int16", + pgType ["float", "double precision", "float8", "pg_catalog.float8"] "ghc-prim" "GHC.Types.Double", + pgType ["real", "float4", "pg_catalog.float4"] "ghc-prim" "GHC.Types.Float", + pgType ["numeric", "pg_catalog.numeric", "money"] "scientific" "Data.Scientific.Scientific", + pgType ["boolean", "bool", "pg_catalog.bool"] "ghc-prim" "GHC.Types.Bool", + pgType ["json", "pg_catalog.json"] "aeson" "Data.Aeson.Value", + pgType ["jsonb", "pg_catalog.jsonb"] "aeson" "Data.Aeson.Value", + pgBinary ["bytea", "blob", "pg_catalog.bytea"], + pgType ["text", "pg_catalog.varchar", "pg_catalog.bpchar", "string", "citext", "name"] "text" "Data.Text.Text" + ] where columnType :: Text columnType = @@ -501,3 +727,78 @@ } | otherwise = Nothing + + pgBinary pgTypes + | columnType `elem` pgTypes = + Just $ + HaskellType + { package = Nothing, + module' = Nothing, + name = Just "Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString" + } + :| [ HaskellType + { package = Just "bytestring", + module' = Just "Data.ByteString", + name = Nothing + }, + HaskellType + { package = Just "postgresql-simple", + module' = Just "Database.PostgreSQL.Simple", + name = Nothing + } + ] + | otherwise = + Nothing + +-- | Swaps every occurrence of "$x" with ? as that's what the *-simple libraries +-- understand only. +mangleQuery :: Text -> Text +mangleQuery = + unQuestionmark . dollarsToQuestionmark + where + -- Replace '$x' with '?' + dollarsToQuestionmark = + Data.Text.intercalate "?" + . map (Data.Text.dropWhile Data.Char.isDigit) + . Data.Text.splitOn "$" + + -- Replace '(?)' with '?' + -- Due to pretty printing and formatting it could look like + -- + -- ( + -- ? + -- ) + -- + unQuestionmark = + Data.Text.intercalate "?" . go . Data.Text.splitOn "?" + where + go [] = [] + go [x] = [x] + go (left : right : rest) + | Just left <- Data.Text.stripSuffix "(" (Data.Text.stripEnd left), + Just right <- Data.Text.stripPrefix ")" (Data.Text.stripStart right) = + go (left : right : rest) + | otherwise = + left : go (right : rest) + +-- | The 1-based parameter indices referenced by a query's SQL text, in order. +-- +-- PostgreSQL uses numbered placeholders (@$1@, @$2@) which may repeat or appear +-- out of order, so we read the explicit numbers. SQLite uses positional @?@ +-- placeholders with no number; for the @sqlite@ engine we emit sequential +-- indices @[1..n]@ matching the parameter list order. +-- +-- The @?@ fallback is deliberately scoped to SQLite: PostgreSQL always uses +-- @$n@, and the MySQL path is left on the numbered behaviour to avoid changing +-- it here. Only SQLite needs (and gets) the positional-@?@ handling. +queryParamBindings :: Text -> Text -> [Int] +queryParamBindings engine query = + case numbered of + [] | engine == "sqlite" -> [1 .. Data.Text.count "?" query] + bindings -> bindings + where + numbered = + catMaybes + [ readMaybe (toString (Data.Text.takeWhile Data.Char.isDigit x)) + | x <- Data.Text.splitOn "$" query + ] diff --git a/templates/internal.mysql.hs.jinja b/templates/internal.mysql.hs.jinja --- a/templates/internal.mysql.hs.jinja +++ b/templates/internal.mysql.hs.jinja @@ -5,6 +5,7 @@ Query(..), Params, Result, + {{ moduleName }}.Enum, -- * :execResult ExecResult(..), @@ -45,6 +46,8 @@ data family Params (name :: Symbol) data family Result (name :: Symbol) + +data family Enum (name :: Symbol) data ExecResult = ExecResult { lastInsertId :: !Data.Int.Int64, diff --git a/templates/internal.postgresql.hs.jinja b/templates/internal.postgresql.hs.jinja --- a/templates/internal.postgresql.hs.jinja +++ b/templates/internal.postgresql.hs.jinja @@ -6,6 +6,7 @@ Query(..), Params, Result, + {{ moduleName }}.Enum, -- * :execResult ExecResult(..), @@ -24,17 +25,24 @@ queryMany, fold, + -- * :copyfrom + execMany, + -- * Reexports Database.PostgreSQL.Simple.Connection, Database.PostgreSQL.Simple.ToRow, Database.PostgreSQL.Simple.FromRow, ) where +import Data.Foldable (Foldable) +import qualified Data.Foldable import Data.Vector (Vector) import Database.PostgreSQL.Simple (Connection, FromRow, ToRow) import GHC.TypeLits (Symbol) +import qualified Data.ByteString.Char8 import qualified Data.Int import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.Types import qualified Database.PostgreSQL.Simple.Vector newtype Query (name :: Symbol) (command :: Symbol) @@ -44,6 +52,8 @@ data family Result (name :: Symbol) +data family Enum (name :: Symbol) + data ExecResult = ExecResult { rowsAffected :: !Data.Int.Int64 } @@ -64,8 +74,8 @@ Query name ":execrows" -> Params name -> IO Data.Int.Int64 -execRows connection (Query sql) = do - Database.PostgreSQL.Simple.execute connection sql +execRows connection (Query sql) params = do + Database.PostgreSQL.Simple.execute connection sql params execResult :: (ToRow (Params name)) => @@ -97,9 +107,18 @@ Query name ":many" -> Params name -> IO (Vector (Result name)) -queryMany connection (Query sql) = - Database.PostgreSQL.Simple.Vector.query connection sql +queryMany connection (Query sql) params = + Database.PostgreSQL.Simple.Vector.query connection sql params +execMany :: + (ToRow (Params name), FromRow (Result name), Foldable f) => + Connection -> + Query name ":copyfrom" -> + f (Params name) -> + IO Data.Int.Int64 +execMany connection (Query sql) params = + Database.PostgreSQL.Simple.executeMany connection sql (Data.Foldable.toList params) + fold :: (ToRow (Params name), FromRow (Result name)) => Connection -> @@ -108,6 +127,6 @@ a -> (a -> Result name -> IO a) -> IO a -fold connection (Query sql) = - Database.PostgreSQL.Simple.fold connection sql +fold connection (Query sql) params = do + Database.PostgreSQL.Simple.fold connection sql params {-# INLINABLE fold #-} diff --git a/templates/internal.sqlite.hs.jinja b/templates/internal.sqlite.hs.jinja --- a/templates/internal.sqlite.hs.jinja +++ b/templates/internal.sqlite.hs.jinja @@ -7,6 +7,7 @@ Query(..), Params, Result, + {{ moduleName }}.Enum, -- * :execResult ExecResult(..), @@ -47,6 +48,8 @@ data family Params (name :: Symbol) data family Result (name :: Symbol) + +data family Enum (name :: Symbol) data ExecResult = ExecResult { lastInsertId :: !Data.Int.Int64, diff --git a/templates/package.cabal.jinja b/templates/package.cabal.jinja --- a/templates/package.cabal.jinja +++ b/templates/package.cabal.jinja @@ -10,3 +10,9 @@ {% for module in exposedModules %} {{ module.value }} {% endfor %} + {% if !(defaultExtensions | empty) %} + default-extensions: + {% for defaultExtension in defaultExtensions %} + {{ defaultExtension.value }} + {% endfor %} + {% endif %} diff --git a/templates/query.hs.jinja b/templates/query.hs.jinja --- a/templates/query.hs.jinja +++ b/templates/query.hs.jinja @@ -8,18 +8,21 @@ {-# LANGUAGE TypeFamilies #-} module {{moduleName}} where -import {{ internalModuleName }} (Query(..), Params, Result) {% if generatePostgresql %} +import {{ internalModuleName }} (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple import qualified Database.PostgreSQL.Simple.FromRow import qualified Database.PostgreSQL.Simple.ToField import qualified Database.PostgreSQL.Simple.ToRow {% endif %} {% if generateSqlite %} +import {{ internalModuleName }} (Query(..), Enum, Params, Result) import qualified Database.SQLite.Simple.FromRow import qualified Database.SQLite.Simple.ToField import qualified Database.SQLite.Simple.ToRow {% endif %} {% if generateMysql %} +import {{ internalModuleName }} (Query(..), Enum, Params, Result) import qualified Database.MySQL.Simple.Param import qualified Database.MySQL.Simple.QueryParams import qualified Database.MySQL.Simple.QueryResults @@ -43,46 +46,54 @@ data instance Result {{ escapedQueryName }} = {{ haskellResultName }} { {% for column in resultColumns %} - {{ column.value.name }} :: !{{ column.value.type }}{% if !column.last %},{% endif %} + {{ column.value.name }} :: !({{ column.value.type }}){% if !column.last %},{% endif %} {% endfor %} } {% if generatePostgresql %} instance Database.PostgreSQL.Simple.ToRow.ToRow (Params {{ escapedQueryName }}) where toRow {{ haskellParamsName }}{% if parameterColumns | empty %}{}{% else %}{..}{% endif%} = - [ {% for param in parameterColumns %} + [ {% for param in queryColumns %} + {% if param.value.slice %} + {% if param.value.notNull %} + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList {{ param.value.name }})){% if !param.last %}, {% endif %} + {% else %} + Database.PostgreSQL.Simple.ToField.toField (fmap (Database.PostgreSQL.Simple.In . Data.Foldable.toList) {{ param.value.name }}){% if !param.last %}, {% endif %} + {% endif %} + {% else %} Database.PostgreSQL.Simple.ToField.toField {{ param.value.name }}{% if !param.last %}, {% endif %} + {% endif %} {% endfor %} ] instance Database.PostgreSQL.Simple.FromRow.FromRow (Result {{ escapedQueryName }}) where fromRow = - {{ haskellResultName }} + pure {{ haskellResultName }} {% for column in resultColumns %} - {% if column.first %}<$>{% else %}<*>{% endif%} Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field {% endfor %} {% endif %} {% if generateSqlite %} instance Database.SQLite.Simple.ToRow.ToRow (Params {{ escapedQueryName }}) where toRow {{ haskellParamsName }}{% if parameterColumns | empty %}{}{% else %}{..}{% endif%} = - [ {% for param in parameterColumns %} + [ {% for param in queryColumns %} Database.SQLite.Simple.ToField.toField {{ param.value.name }}{% if !param.last %}, {% endif %} {% endfor %} ] instance Database.SQLite.Simple.FromRow.FromRow (Result {{ escapedQueryName }}) where fromRow = - {{ haskellResultName }} + pure {{ haskellResultName }} {% for column in resultColumns %} - {% if column.first %}<$>{% else %}<*>{% endif%} Database.SQLite.Simple.FromRow.field + <*> Database.SQLite.Simple.FromRow.field {% endfor %} {% endif %} {% if generateMysql %} instance Database.MySQL.Simple.QueryParams.QueryParams (Params {{ escapedQueryName }}) where renderParams {{ haskellParamsName }}{% if parameterColumns | empty %}{}{% else %}{..}{% endif%} = - [ {% for param in parameterColumns %} + [ {% for param in queryColumns %} Database.MySQL.Simple.Param.render {{ param.value.name }}{% if !param.last %}, {% endif %} {% endfor %} ] diff --git a/templates/toplevel.hs.jinja b/templates/toplevel.hs.jinja --- a/templates/toplevel.hs.jinja +++ b/templates/toplevel.hs.jinja @@ -1,10 +1,14 @@ module {{ moduleName }} ( module {{ internalModuleName }}, + module {{ typesModuleName }}, + {% if !(modules | empty) %} module Queries + {% endif %} ) where -import qualified {{ internalModuleName }} +import {{ internalModuleName }} +import {{ typesModuleName }} {% for module in modules %} -import qualified {{ module.value }} as Queries +import {{ module.value }} as Queries {% endfor %} diff --git a/templates/types.hs.jinja b/templates/types.hs.jinja new file mode 100644 --- /dev/null +++ b/templates/types.hs.jinja @@ -0,0 +1,62 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module {{moduleName}} where + +{% if generatePostgresql %} +import qualified Control.Monad +import qualified Data.Text +import qualified Database.PostgreSQL.Simple.FromField +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow +{% endif %} +{% if generateSqlite %} +import qualified Database.SQLite.Simple.FromRow +import qualified Database.SQLite.Simple.ToField +import qualified Database.SQLite.Simple.ToRow +{% endif %} +{% if generateMysql %} +import qualified Database.MySQL.Simple.Param +import qualified Database.MySQL.Simple.QueryParams +import qualified Database.MySQL.Simple.QueryResults +import qualified Database.MySQL.Simple.Result +{% endif %} +import {{ internalModuleName }} +import Prelude hiding (Enum) +import qualified Prelude + +{% for enum in enums %} +data instance Enum {{ enum.value.escapedEnumName }} + {% for value in enum.value.values %} + {% if value.first %}={% else %}|{%endif%} {{ value.value.haskellConstructorName }} + {% endfor %} + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +{% if generatePostgresql %} +instance Database.PostgreSQL.Simple.ToField.ToField (Enum {{ enum.value.escapedEnumName }}) where + {% for value in enum.value.values %} + toField {{ value.value.haskellConstructorName }} = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text {{ value.value.escapedEnumValue }} + {% endfor %} + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum {{ enum.value.escapedEnumName }}) where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= {{ enum.value.escapedEnumName }}) $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + {% for value in enum.value.values %} + Just {{ value.value.escapedEnumValue }} -> pure {{ value.value.haskellConstructorName }} + {% endfor %} + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" +{% endif %} + +{% endfor %} diff --git a/test/Test/Sqlc/Hs/Golden.hs b/test/Test/Sqlc/Hs/Golden.hs --- a/test/Test/Sqlc/Hs/Golden.hs +++ b/test/Test/Sqlc/Hs/Golden.hs @@ -6,7 +6,7 @@ import Proto.Protos.Codegen qualified import System.Directory qualified import System.Exit (ExitCode (..)) -import System.FilePath (dropExtension, ()) +import System.FilePath (takeExtension, dropExtension, (), replaceExtension) import System.IO qualified import System.IO.Error qualified import System.IO.Temp qualified @@ -18,7 +18,7 @@ test_golden :: IO [TestTree] test_golden = do - inputs <- findByExtension [".input"] "test/golden" + inputs <- findByExtension [".input", ".proto"] "test/golden" pure $ inputs <&> \input -> withResource @@ -49,11 +49,25 @@ Data.ByteString.readFile input message <- - case Data.ProtoLens.readMessage @Proto.Protos.Codegen.GenerateRequest (toLazy (decodeUtf8 message)) of - Left errorMessage -> - error (toText errorMessage) - Right message -> - pure message + case takeExtension input of + ".input" -> + case Data.ProtoLens.readMessage @Proto.Protos.Codegen.GenerateRequest (toLazy (decodeUtf8 message)) of + Left errorMessage -> + error (toText errorMessage) + Right message -> + pure message + ".proto" -> do + message <- + case Data.ProtoLens.decodeMessage @Proto.Protos.Codegen.GenerateRequest message of + Left errorMessage -> + error (toText errorMessage) + Right message -> + pure message + + writeFile (replaceExtension input ".input") (Data.ProtoLens.showMessage message) + pure message + _ -> + error "Impossible: invalid extension" (exitCode, stdout, stderr) <- System.Process.ByteString.readProcessWithExitCode diff --git a/test/golden/column-override-sqlite.input b/test/golden/column-override-sqlite.input new file mode 100644 --- /dev/null +++ b/test/golden/column-override-sqlite.input @@ -0,0 +1,29 @@ +settings { + engine: "sqlite" +} + +queries { + text: "SELECT provider, CAST(COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ', last_attempt_at), '') AS TEXT) AS last_error_at FROM fetch_state;" + name: "GetLastErrors" + cmd: ":many" + filename: "query/fetch_state.sql" + columns { + name: "provider" + not_null: true + table { + name: "fetch_state" + } + type { + name: "TEXT" + } + } + columns { + name: "last_error_at" + not_null: true + type { + name: "TEXT" + } + } +} + +global_options: "{ \"cabal_package_name\": \"column-override-sqlite\", \"overrides\": [ { \"column\": \"last_error_at\", \"haskell_type\": { \"package\": \"time\", \"module\": \"Data.Time\", \"type\": \"Data.Time.UTCTime\" } } ] }" diff --git a/test/golden/column-override-sqlite/Queries.hs b/test/golden/column-override-sqlite/Queries.hs new file mode 100644 --- /dev/null +++ b/test/golden/column-override-sqlite/Queries.hs @@ -0,0 +1,10 @@ +module Queries + ( module Queries.Internal, + module Queries.Types, + module Queries + ) +where + +import Queries.Internal +import Queries.Types +import Queries.GetLastErrors as Queries diff --git a/test/golden/column-override-sqlite/Queries/GetLastErrors.hs b/test/golden/column-override-sqlite/Queries/GetLastErrors.hs new file mode 100644 --- /dev/null +++ b/test/golden/column-override-sqlite/Queries/GetLastErrors.hs @@ -0,0 +1,43 @@ +{- This file was auto-generated from query/fetch_state.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.GetLastErrors where + +import Queries.Internal (Query(..), Enum, Params, Result) +import qualified Database.SQLite.Simple.FromRow +import qualified Database.SQLite.Simple.ToField +import qualified Database.SQLite.Simple.ToRow + +import qualified Data.Text +import qualified Data.Time +import qualified Data.Foldable + +query_GetLastErrors :: Query "GetLastErrors" ":many" +query_GetLastErrors = Query "SELECT provider, CAST(COALESCE(strftime('%Y-%m-%dT%H:%M:%SZ', last_attempt_at), '') AS TEXT) AS last_error_at FROM fetch_state;" + +data instance Params "GetLastErrors" = Params_GetLastErrors + { + } + +data instance Result "GetLastErrors" = Result_GetLastErrors + { + fetch_state_provider :: !(Data.Text.Text), + last_error_at :: !(Data.Time.UTCTime) + } + + +instance Database.SQLite.Simple.ToRow.ToRow (Params "GetLastErrors") where + toRow Params_GetLastErrors{} = + [ ] + +instance Database.SQLite.Simple.FromRow.FromRow (Result "GetLastErrors") where + fromRow = + pure Result_GetLastErrors + <*> Database.SQLite.Simple.FromRow.field + <*> Database.SQLite.Simple.FromRow.field + diff --git a/test/golden/column-override-sqlite/Queries/Internal.hs b/test/golden/column-override-sqlite/Queries/Internal.hs new file mode 100644 --- /dev/null +++ b/test/golden/column-override-sqlite/Queries/Internal.hs @@ -0,0 +1,151 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Internal ( + Query(..), + Params, + Result, + Queries.Internal.Enum, + + -- * :execResult + ExecResult(..), + execResult, + + -- * :exec + exec, + + -- * :execrows + execRows, + + -- * :execlastid + execLastId, + + -- * :one + queryOne, + + -- * :many + queryMany, + fold, + + -- * Reexports + Database.SQLite.Simple.Connection, + Database.SQLite.Simple.ToRow, + Database.SQLite.Simple.FromRow, + ) where + +import Database.SQLite.Simple (Connection, FromRow, ToRow) +import GHC.TypeLits (Symbol) +import qualified Data.Int +import qualified Database.SQLite.Simple +import qualified Data.Vector +import qualified Data.Vector.Mutable + +newtype Query (name :: Symbol) (command :: Symbol) + = Query Database.SQLite.Simple.Query + +data family Params (name :: Symbol) + +data family Result (name :: Symbol) + +data family Enum (name :: Symbol) + +data ExecResult = ExecResult + { lastInsertId :: !Data.Int.Int64, + rowsAffected :: !Data.Int.Int64 + } + +exec :: + (ToRow (Params name)) => + Connection -> + Query name ":exec" -> + Params name -> + IO () +exec connection (Query sql) = + Database.SQLite.Simple.execute connection sql + +execRows :: + (ToRow (Params name)) => + Connection -> + Query name ":execrows" -> + Params name -> + IO Data.Int.Int64 +execRows connection (Query sql) params = do + Database.SQLite.Simple.execute connection sql params + rowsAffected <- Database.SQLite.Simple.changes connection + pure (fromIntegral rowsAffected) + +execLastId :: + (ToRow (Params name)) => + Connection -> + Query name ":execlastid" -> + Params name -> + IO Data.Int.Int64 +execLastId connection (Query sql) params = do + Database.SQLite.Simple.execute connection sql params + lastInsertId <- Database.SQLite.Simple.lastInsertRowId connection + pure lastInsertId + +execResult :: + (ToRow (Params name)) => + Connection -> + Query name ":execresult" -> + Params name -> + IO ExecResult +execResult connection (Query sql) params = do + Database.SQLite.Simple.execute connection sql params + rowsAffected <- Database.SQLite.Simple.changes connection + lastInsertId <- Database.SQLite.Simple.lastInsertRowId connection + pure ExecResult { + lastInsertId, + rowsAffected = fromIntegral rowsAffected + } + +queryOne :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":one" -> + Params name -> + IO (Maybe (Result name)) +queryOne connection (Query sql) params = do + result <- Database.SQLite.Simple.query connection sql params + case result of + [] -> pure Nothing + x : _ -> pure (Just x) + +data Grow v = Grow !Int !v + +queryMany :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + IO (Data.Vector.Vector (Result name)) +queryMany connection query params = do + vector <- Data.Vector.Mutable.unsafeNew 4 + Grow i vector <- fold connection query params (Grow 0 vector) step + vector <- Data.Vector.unsafeFreeze vector + pure $! Data.Vector.unsafeTake i vector + where + step (Grow i vector) !result + | i < Data.Vector.Mutable.length vector = do + Data.Vector.Mutable.unsafeWrite vector i result + pure $! Grow (i + 1) vector + | otherwise = do + -- Grow vector exponentially by doubling its size + vector <- Data.Vector.Mutable.unsafeGrow vector i + Data.Vector.Mutable.unsafeWrite vector i result + pure $! Grow (i + 1) vector + +fold :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + a -> + (a -> Result name -> IO a) -> + IO a +fold connection (Query sql) = + Database.SQLite.Simple.fold connection sql +{-# INLINABLE fold #-} diff --git a/test/golden/column-override-sqlite/Queries/Types.hs b/test/golden/column-override-sqlite/Queries/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/column-override-sqlite/Queries/Types.hs @@ -0,0 +1,19 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Types where + +import qualified Database.SQLite.Simple.FromRow +import qualified Database.SQLite.Simple.ToField +import qualified Database.SQLite.Simple.ToRow +import Queries.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/column-override-sqlite/column-override-sqlite.cabal b/test/golden/column-override-sqlite/column-override-sqlite.cabal new file mode 100644 --- /dev/null +++ b/test/golden/column-override-sqlite/column-override-sqlite.cabal @@ -0,0 +1,16 @@ +cabal-version: 3.0 +name: column-override-sqlite +version: 0.1.0.0 +library + build-depends: + base, + bytestring, + sqlite-simple, + text, + time, + vector, + exposed-modules: + Queries + Queries.GetLastErrors + Queries.Internal + Queries.Types diff --git a/test/golden/column-override.input b/test/golden/column-override.input new file mode 100644 --- /dev/null +++ b/test/golden/column-override.input @@ -0,0 +1,48 @@ +settings { + engine: "postgresql" +} + +queries { + text: "SELECT id, name, CAST(created_at AS TEXT) AS created_at FROM users WHERE $1 > 42;" + name: "ListUsers" + cmd: "SELECT" + filename: "query/users.sql" + columns { + name: "id" + not_null: true + table { + name: "users" + } + type { + name: "int" + } + } + columns { + name: "name" + not_null: true + table { + name: "users" + } + type { + name: "text" + } + } + columns { + name: "created_at" + not_null: true + type { + name: "text" + } + } + params { + column { + name: "age" + not_null: true + type { + name: "int" + } + } + } +} + +global_options: "{ \"overrides\": [ { \"column\": \"users.id\", \"haskell_type\": { \"package\": \"uuid\", \"module\": \"Data.UUID\", \"type\": \"Data.UUID.UUID\" } }, { \"column\": \"created_at\", \"haskell_type\": { \"package\": \"time\", \"module\": \"Data.Time\", \"type\": \"Data.Time.UTCTime\" } } ] }" diff --git a/test/golden/column-override/Queries.hs b/test/golden/column-override/Queries.hs new file mode 100644 --- /dev/null +++ b/test/golden/column-override/Queries.hs @@ -0,0 +1,10 @@ +module Queries + ( module Queries.Internal, + module Queries.Types, + module Queries + ) +where + +import Queries.Internal +import Queries.Types +import Queries.ListUsers as Queries diff --git a/test/golden/column-override/Queries/Internal.hs b/test/golden/column-override/Queries/Internal.hs new file mode 100644 --- /dev/null +++ b/test/golden/column-override/Queries/Internal.hs @@ -0,0 +1,132 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Internal ( + Query(..), + Params, + Result, + Queries.Internal.Enum, + + -- * :execResult + ExecResult(..), + execResult, + + -- * :exec + exec, + + -- * :execrows + execRows, + + -- * :one + queryOne, + + -- * :many + queryMany, + fold, + + -- * :copyfrom + execMany, + + -- * Reexports + Database.PostgreSQL.Simple.Connection, + Database.PostgreSQL.Simple.ToRow, + Database.PostgreSQL.Simple.FromRow, + ) where + +import Data.Foldable (Foldable) +import qualified Data.Foldable +import Data.Vector (Vector) +import Database.PostgreSQL.Simple (Connection, FromRow, ToRow) +import GHC.TypeLits (Symbol) +import qualified Data.ByteString.Char8 +import qualified Data.Int +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.Types +import qualified Database.PostgreSQL.Simple.Vector + +newtype Query (name :: Symbol) (command :: Symbol) + = Query Database.PostgreSQL.Simple.Query + +data family Params (name :: Symbol) + +data family Result (name :: Symbol) + +data family Enum (name :: Symbol) + +data ExecResult = ExecResult + { rowsAffected :: !Data.Int.Int64 + } + +exec :: + (ToRow (Params name)) => + Connection -> + Query name ":exec" -> + Params name -> + IO () +exec connection (Query sql) params = do + _rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure () + +execRows :: + (ToRow (Params name)) => + Connection -> + Query name ":execrows" -> + Params name -> + IO Data.Int.Int64 +execRows connection (Query sql) params = do + Database.PostgreSQL.Simple.execute connection sql params + +execResult :: + (ToRow (Params name)) => + Connection -> + Query name ":execresult" -> + Params name -> + IO ExecResult +execResult connection (Query sql) params = do + rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure ExecResult { + rowsAffected + } + +queryOne :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":one" -> + Params name -> + IO (Maybe (Result name)) +queryOne connection (Query sql) params = do + result <- Database.PostgreSQL.Simple.query connection sql params + case result of + [] -> pure Nothing + x : _ -> pure (Just x) + +queryMany :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + IO (Vector (Result name)) +queryMany connection (Query sql) params = + Database.PostgreSQL.Simple.Vector.query connection sql params + +execMany :: + (ToRow (Params name), FromRow (Result name), Foldable f) => + Connection -> + Query name ":copyfrom" -> + f (Params name) -> + IO Data.Int.Int64 +execMany connection (Query sql) params = + Database.PostgreSQL.Simple.executeMany connection sql (Data.Foldable.toList params) + +fold :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + a -> + (a -> Result name -> IO a) -> + IO a +fold connection (Query sql) params = do + Database.PostgreSQL.Simple.fold connection sql params +{-# INLINABLE fold #-} diff --git a/test/golden/column-override/Queries/ListUsers.hs b/test/golden/column-override/Queries/ListUsers.hs new file mode 100644 --- /dev/null +++ b/test/golden/column-override/Queries/ListUsers.hs @@ -0,0 +1,49 @@ +{- This file was auto-generated from query/users.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.ListUsers where + +import Queries.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.UUID +import qualified Data.Text +import qualified Data.Time +import qualified Data.Foldable + +query_ListUsers :: Query "ListUsers" "SELECT" +query_ListUsers = Query "SELECT id, name, CAST(created_at AS TEXT) AS created_at FROM users WHERE ? > 42;" + +data instance Params "ListUsers" = Params_ListUsers + { + age :: Data.Int.Int32 + } + +data instance Result "ListUsers" = Result_ListUsers + { + users_id :: !(Data.UUID.UUID), + users_name :: !(Data.Text.Text), + created_at :: !(Data.Time.UTCTime) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "ListUsers") where + toRow Params_ListUsers{..} = + [ ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "ListUsers") where + fromRow = + pure Result_ListUsers + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/column-override/Queries/Types.hs b/test/golden/column-override/Queries/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/column-override/Queries/Types.hs @@ -0,0 +1,22 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Types where + +import qualified Control.Monad +import qualified Data.Text +import qualified Database.PostgreSQL.Simple.FromField +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow +import Queries.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/column-override/queries.cabal b/test/golden/column-override/queries.cabal new file mode 100644 --- /dev/null +++ b/test/golden/column-override/queries.cabal @@ -0,0 +1,17 @@ +cabal-version: 3.0 +name: queries +version: 0.1.0.0 +library + build-depends: + base, + bytestring, + postgresql-simple, + text, + time, + uuid, + vector, + exposed-modules: + Queries + Queries.Internal + Queries.ListUsers + Queries.Types diff --git a/test/golden/empty/Queries.hs b/test/golden/empty/Queries.hs --- a/test/golden/empty/Queries.hs +++ b/test/golden/empty/Queries.hs @@ -1,7 +1,8 @@ module Queries ( module Queries.Internal, - module Queries + module Queries.Types, ) where -import qualified Queries.Internal +import Queries.Internal +import Queries.Types diff --git a/test/golden/empty/Queries/Internal.hs b/test/golden/empty/Queries/Internal.hs --- a/test/golden/empty/Queries/Internal.hs +++ b/test/golden/empty/Queries/Internal.hs @@ -6,6 +6,7 @@ Query(..), Params, Result, + Queries.Internal.Enum, -- * :execResult ExecResult(..), @@ -24,17 +25,24 @@ queryMany, fold, + -- * :copyfrom + execMany, + -- * Reexports Database.PostgreSQL.Simple.Connection, Database.PostgreSQL.Simple.ToRow, Database.PostgreSQL.Simple.FromRow, ) where +import Data.Foldable (Foldable) +import qualified Data.Foldable import Data.Vector (Vector) import Database.PostgreSQL.Simple (Connection, FromRow, ToRow) import GHC.TypeLits (Symbol) +import qualified Data.ByteString.Char8 import qualified Data.Int import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.Types import qualified Database.PostgreSQL.Simple.Vector newtype Query (name :: Symbol) (command :: Symbol) @@ -44,6 +52,8 @@ data family Result (name :: Symbol) +data family Enum (name :: Symbol) + data ExecResult = ExecResult { rowsAffected :: !Data.Int.Int64 } @@ -64,8 +74,8 @@ Query name ":execrows" -> Params name -> IO Data.Int.Int64 -execRows connection (Query sql) = do - Database.PostgreSQL.Simple.execute connection sql +execRows connection (Query sql) params = do + Database.PostgreSQL.Simple.execute connection sql params execResult :: (ToRow (Params name)) => @@ -97,9 +107,18 @@ Query name ":many" -> Params name -> IO (Vector (Result name)) -queryMany connection (Query sql) = - Database.PostgreSQL.Simple.Vector.query connection sql +queryMany connection (Query sql) params = + Database.PostgreSQL.Simple.Vector.query connection sql params +execMany :: + (ToRow (Params name), FromRow (Result name), Foldable f) => + Connection -> + Query name ":copyfrom" -> + f (Params name) -> + IO Data.Int.Int64 +execMany connection (Query sql) params = + Database.PostgreSQL.Simple.executeMany connection sql (Data.Foldable.toList params) + fold :: (ToRow (Params name), FromRow (Result name)) => Connection -> @@ -108,6 +127,6 @@ a -> (a -> Result name -> IO a) -> IO a -fold connection (Query sql) = - Database.PostgreSQL.Simple.fold connection sql +fold connection (Query sql) params = do + Database.PostgreSQL.Simple.fold connection sql params {-# INLINABLE fold #-} diff --git a/test/golden/empty/Queries/Types.hs b/test/golden/empty/Queries/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/empty/Queries/Types.hs @@ -0,0 +1,16 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Types where + +import Queries.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/empty/queries.cabal b/test/golden/empty/queries.cabal --- a/test/golden/empty/queries.cabal +++ b/test/golden/empty/queries.cabal @@ -4,8 +4,11 @@ library build-depends: base, + bytestring, postgresql-simple, + text, vector, exposed-modules: Queries Queries.Internal + Queries.Types diff --git a/test/golden/multiple-param-mentions.input b/test/golden/multiple-param-mentions.input new file mode 100644 --- /dev/null +++ b/test/golden/multiple-param-mentions.input @@ -0,0 +1,36 @@ +settings { + engine: "postgresql" +} + +queries { + text: "SELECT * FROM users WHERE $1::TEXT IS NULL OR $1::TEXT = users.name ;" + name: "ListUsers" + cmd: "SELECT" + filename: "query/users.sql" + columns { + name: "id" + not_null: true + type { + name: "int" + } + } + columns { + name: "name" + not_null: true + type { + name: "text" + } + } + params { + number: 1 + column { + name: "name" + not_null: true + type { + name: "text" + } + } + } +} + +global_options: "{ \"cabal_package_name\": \"simple-query-postgresql\" }" diff --git a/test/golden/multiple-param-mentions/Queries.hs b/test/golden/multiple-param-mentions/Queries.hs new file mode 100644 --- /dev/null +++ b/test/golden/multiple-param-mentions/Queries.hs @@ -0,0 +1,10 @@ +module Queries + ( module Queries.Internal, + module Queries.Types, + module Queries + ) +where + +import Queries.Internal +import Queries.Types +import Queries.ListUsers as Queries diff --git a/test/golden/multiple-param-mentions/Queries/Internal.hs b/test/golden/multiple-param-mentions/Queries/Internal.hs new file mode 100644 --- /dev/null +++ b/test/golden/multiple-param-mentions/Queries/Internal.hs @@ -0,0 +1,132 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Internal ( + Query(..), + Params, + Result, + Queries.Internal.Enum, + + -- * :execResult + ExecResult(..), + execResult, + + -- * :exec + exec, + + -- * :execrows + execRows, + + -- * :one + queryOne, + + -- * :many + queryMany, + fold, + + -- * :copyfrom + execMany, + + -- * Reexports + Database.PostgreSQL.Simple.Connection, + Database.PostgreSQL.Simple.ToRow, + Database.PostgreSQL.Simple.FromRow, + ) where + +import Data.Foldable (Foldable) +import qualified Data.Foldable +import Data.Vector (Vector) +import Database.PostgreSQL.Simple (Connection, FromRow, ToRow) +import GHC.TypeLits (Symbol) +import qualified Data.ByteString.Char8 +import qualified Data.Int +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.Types +import qualified Database.PostgreSQL.Simple.Vector + +newtype Query (name :: Symbol) (command :: Symbol) + = Query Database.PostgreSQL.Simple.Query + +data family Params (name :: Symbol) + +data family Result (name :: Symbol) + +data family Enum (name :: Symbol) + +data ExecResult = ExecResult + { rowsAffected :: !Data.Int.Int64 + } + +exec :: + (ToRow (Params name)) => + Connection -> + Query name ":exec" -> + Params name -> + IO () +exec connection (Query sql) params = do + _rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure () + +execRows :: + (ToRow (Params name)) => + Connection -> + Query name ":execrows" -> + Params name -> + IO Data.Int.Int64 +execRows connection (Query sql) params = do + Database.PostgreSQL.Simple.execute connection sql params + +execResult :: + (ToRow (Params name)) => + Connection -> + Query name ":execresult" -> + Params name -> + IO ExecResult +execResult connection (Query sql) params = do + rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure ExecResult { + rowsAffected + } + +queryOne :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":one" -> + Params name -> + IO (Maybe (Result name)) +queryOne connection (Query sql) params = do + result <- Database.PostgreSQL.Simple.query connection sql params + case result of + [] -> pure Nothing + x : _ -> pure (Just x) + +queryMany :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + IO (Vector (Result name)) +queryMany connection (Query sql) params = + Database.PostgreSQL.Simple.Vector.query connection sql params + +execMany :: + (ToRow (Params name), FromRow (Result name), Foldable f) => + Connection -> + Query name ":copyfrom" -> + f (Params name) -> + IO Data.Int.Int64 +execMany connection (Query sql) params = + Database.PostgreSQL.Simple.executeMany connection sql (Data.Foldable.toList params) + +fold :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + a -> + (a -> Result name -> IO a) -> + IO a +fold connection (Query sql) params = do + Database.PostgreSQL.Simple.fold connection sql params +{-# INLINABLE fold #-} diff --git a/test/golden/multiple-param-mentions/Queries/ListUsers.hs b/test/golden/multiple-param-mentions/Queries/ListUsers.hs new file mode 100644 --- /dev/null +++ b/test/golden/multiple-param-mentions/Queries/ListUsers.hs @@ -0,0 +1,49 @@ +{- This file was auto-generated from query/users.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.ListUsers where + +import Queries.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Text +import qualified Data.Int +import qualified Data.Foldable + +query_ListUsers :: Query "ListUsers" "SELECT" +query_ListUsers = Query "SELECT * FROM users WHERE ?::TEXT IS NULL OR ?::TEXT = users.name ;" + +data instance Params "ListUsers" = Params_ListUsers + { + name :: Data.Text.Text + } + +data instance Result "ListUsers" = Result_ListUsers + { + id :: !(Data.Int.Int32), + name :: !(Data.Text.Text) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "ListUsers") where + toRow Params_ListUsers{..} = + [ + Database.PostgreSQL.Simple.ToField.toField name, + + Database.PostgreSQL.Simple.ToField.toField name + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "ListUsers") where + fromRow = + pure Result_ListUsers + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/multiple-param-mentions/Queries/Types.hs b/test/golden/multiple-param-mentions/Queries/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/multiple-param-mentions/Queries/Types.hs @@ -0,0 +1,22 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Types where + +import qualified Control.Monad +import qualified Data.Text +import qualified Database.PostgreSQL.Simple.FromField +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow +import Queries.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/multiple-param-mentions/simple-query-postgresql.cabal b/test/golden/multiple-param-mentions/simple-query-postgresql.cabal new file mode 100644 --- /dev/null +++ b/test/golden/multiple-param-mentions/simple-query-postgresql.cabal @@ -0,0 +1,15 @@ +cabal-version: 3.0 +name: simple-query-postgresql +version: 0.1.0.0 +library + build-depends: + base, + bytestring, + postgresql-simple, + text, + vector, + exposed-modules: + Queries + Queries.Internal + Queries.ListUsers + Queries.Types diff --git a/test/golden/naming-templates.input b/test/golden/naming-templates.input new file mode 100644 --- /dev/null +++ b/test/golden/naming-templates.input @@ -0,0 +1,48 @@ +settings { + engine: "postgresql" +} + +queries { + text: "SELECT id, name, CAST(now() AS TEXT) AS fetched_at FROM users WHERE $1 > 42;" + name: "ListUsers" + cmd: "SELECT" + filename: "query/users.sql" + columns { + name: "id" + not_null: true + table { + name: "users" + } + type { + name: "int" + } + } + columns { + name: "name" + not_null: true + table { + name: "users" + } + type { + name: "text" + } + } + columns { + name: "fetched_at" + not_null: true + type { + name: "text" + } + } + params { + column { + name: "age" + not_null: true + type { + name: "int" + } + } + } +} + +global_options: "{ \"cabal_package_name\": \"naming-templates\", \"naming\": { \"query\": \"run{{query}}\", \"params_constructor\": \"Mk{{query}}Args\", \"result_constructor\": \"{{query}}Row\", \"field\": \"{{column}}_of_{{table}}\" } }" diff --git a/test/golden/naming-templates/Queries.hs b/test/golden/naming-templates/Queries.hs new file mode 100644 --- /dev/null +++ b/test/golden/naming-templates/Queries.hs @@ -0,0 +1,10 @@ +module Queries + ( module Queries.Internal, + module Queries.Types, + module Queries + ) +where + +import Queries.Internal +import Queries.Types +import Queries.ListUsers as Queries diff --git a/test/golden/naming-templates/Queries/Internal.hs b/test/golden/naming-templates/Queries/Internal.hs new file mode 100644 --- /dev/null +++ b/test/golden/naming-templates/Queries/Internal.hs @@ -0,0 +1,132 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Internal ( + Query(..), + Params, + Result, + Queries.Internal.Enum, + + -- * :execResult + ExecResult(..), + execResult, + + -- * :exec + exec, + + -- * :execrows + execRows, + + -- * :one + queryOne, + + -- * :many + queryMany, + fold, + + -- * :copyfrom + execMany, + + -- * Reexports + Database.PostgreSQL.Simple.Connection, + Database.PostgreSQL.Simple.ToRow, + Database.PostgreSQL.Simple.FromRow, + ) where + +import Data.Foldable (Foldable) +import qualified Data.Foldable +import Data.Vector (Vector) +import Database.PostgreSQL.Simple (Connection, FromRow, ToRow) +import GHC.TypeLits (Symbol) +import qualified Data.ByteString.Char8 +import qualified Data.Int +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.Types +import qualified Database.PostgreSQL.Simple.Vector + +newtype Query (name :: Symbol) (command :: Symbol) + = Query Database.PostgreSQL.Simple.Query + +data family Params (name :: Symbol) + +data family Result (name :: Symbol) + +data family Enum (name :: Symbol) + +data ExecResult = ExecResult + { rowsAffected :: !Data.Int.Int64 + } + +exec :: + (ToRow (Params name)) => + Connection -> + Query name ":exec" -> + Params name -> + IO () +exec connection (Query sql) params = do + _rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure () + +execRows :: + (ToRow (Params name)) => + Connection -> + Query name ":execrows" -> + Params name -> + IO Data.Int.Int64 +execRows connection (Query sql) params = do + Database.PostgreSQL.Simple.execute connection sql params + +execResult :: + (ToRow (Params name)) => + Connection -> + Query name ":execresult" -> + Params name -> + IO ExecResult +execResult connection (Query sql) params = do + rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure ExecResult { + rowsAffected + } + +queryOne :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":one" -> + Params name -> + IO (Maybe (Result name)) +queryOne connection (Query sql) params = do + result <- Database.PostgreSQL.Simple.query connection sql params + case result of + [] -> pure Nothing + x : _ -> pure (Just x) + +queryMany :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + IO (Vector (Result name)) +queryMany connection (Query sql) params = + Database.PostgreSQL.Simple.Vector.query connection sql params + +execMany :: + (ToRow (Params name), FromRow (Result name), Foldable f) => + Connection -> + Query name ":copyfrom" -> + f (Params name) -> + IO Data.Int.Int64 +execMany connection (Query sql) params = + Database.PostgreSQL.Simple.executeMany connection sql (Data.Foldable.toList params) + +fold :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + a -> + (a -> Result name -> IO a) -> + IO a +fold connection (Query sql) params = do + Database.PostgreSQL.Simple.fold connection sql params +{-# INLINABLE fold #-} diff --git a/test/golden/naming-templates/Queries/ListUsers.hs b/test/golden/naming-templates/Queries/ListUsers.hs new file mode 100644 --- /dev/null +++ b/test/golden/naming-templates/Queries/ListUsers.hs @@ -0,0 +1,47 @@ +{- This file was auto-generated from query/users.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.ListUsers where + +import Queries.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Data.Foldable + +runListUsers :: Query "ListUsers" "SELECT" +runListUsers = Query "SELECT id, name, CAST(now() AS TEXT) AS fetched_at FROM users WHERE ? > 42;" + +data instance Params "ListUsers" = MkListUsersArgs + { + age_of_ :: Data.Int.Int32 + } + +data instance Result "ListUsers" = ListUsersRow + { + id_of_users :: !(Data.Int.Int32), + name_of_users :: !(Data.Text.Text), + fetched_at_of_ :: !(Data.Text.Text) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "ListUsers") where + toRow MkListUsersArgs{..} = + [ ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "ListUsers") where + fromRow = + pure ListUsersRow + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/naming-templates/Queries/Types.hs b/test/golden/naming-templates/Queries/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/naming-templates/Queries/Types.hs @@ -0,0 +1,22 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Types where + +import qualified Control.Monad +import qualified Data.Text +import qualified Database.PostgreSQL.Simple.FromField +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow +import Queries.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/naming-templates/naming-templates.cabal b/test/golden/naming-templates/naming-templates.cabal new file mode 100644 --- /dev/null +++ b/test/golden/naming-templates/naming-templates.cabal @@ -0,0 +1,15 @@ +cabal-version: 3.0 +name: naming-templates +version: 0.1.0.0 +library + build-depends: + base, + bytestring, + postgresql-simple, + text, + vector, + exposed-modules: + Queries + Queries.Internal + Queries.ListUsers + Queries.Types diff --git a/test/golden/nested-module/Foo/Bar.hs b/test/golden/nested-module/Foo/Bar.hs --- a/test/golden/nested-module/Foo/Bar.hs +++ b/test/golden/nested-module/Foo/Bar.hs @@ -1,7 +1,8 @@ module Foo.Bar ( module Foo.Bar.Internal, - module Queries + module Foo.Bar.Types, ) where -import qualified Foo.Bar.Internal +import Foo.Bar.Internal +import Foo.Bar.Types diff --git a/test/golden/nested-module/Foo/Bar/Internal.hs b/test/golden/nested-module/Foo/Bar/Internal.hs --- a/test/golden/nested-module/Foo/Bar/Internal.hs +++ b/test/golden/nested-module/Foo/Bar/Internal.hs @@ -5,6 +5,7 @@ Query(..), Params, Result, + Foo.Bar.Internal.Enum, -- * :execResult ExecResult(..), @@ -45,6 +46,8 @@ data family Params (name :: Symbol) data family Result (name :: Symbol) + +data family Enum (name :: Symbol) data ExecResult = ExecResult { lastInsertId :: !Data.Int.Int64, diff --git a/test/golden/nested-module/Foo/Bar/Types.hs b/test/golden/nested-module/Foo/Bar/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/nested-module/Foo/Bar/Types.hs @@ -0,0 +1,20 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Foo.Bar.Types where + +import qualified Database.MySQL.Simple.Param +import qualified Database.MySQL.Simple.QueryParams +import qualified Database.MySQL.Simple.QueryResults +import qualified Database.MySQL.Simple.Result +import Foo.Bar.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/nested-module/nested-module.cabal b/test/golden/nested-module/nested-module.cabal --- a/test/golden/nested-module/nested-module.cabal +++ b/test/golden/nested-module/nested-module.cabal @@ -4,7 +4,10 @@ library build-depends: base, + bytestring, mysql-simple, + text, exposed-modules: Foo.Bar Foo.Bar.Internal + Foo.Bar.Types diff --git a/test/golden/out.input b/test/golden/out.input new file mode 100644 --- /dev/null +++ b/test/golden/out.input @@ -0,0 +1,34754 @@ +settings { + version: "2" + engine: "postgresql" + schema: "db/migrations" + queries: "db/queries.sql" + codegen { + out: "pulse-db" + plugin: "haskell" + options: "{\"cabal_default_extensions\":[\"NoFieldSelectors\"],\"cabal_package_name\":\"pulse-db\",\"haskell_module_prefix\":\"Pulse.Database\",\"overrides\":[{\"db_type\":\"x509_certificate\",\"haskell_type\":[{\"type\":\"Maybe (Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString)\"},{\"module\":\"Data.ByteString\",\"package\":\"bytestring\"},{\"module\":\"Database.PostgreSQL.Simple\",\"package\":\"postgresql-simple\"}],\"nullable\":true},{\"db_type\":\"private_key\",\"haskell_type\":[{\"type\":\"Maybe (Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString)\"},{\"module\":\"Data.ByteString\",\"package\":\"bytestring\"},{\"module\":\"Database.PostgreSQL.Simple\",\"package\":\"postgresql-simple\"}],\"nullable\":true},{\"db_type\":\"x509_certificate\",\"haskell_type\":[{\"type\":\"Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString\"},{\"module\":\"Data.ByteString\",\"package\":\"bytestring\"},{\"module\":\"Database.PostgreSQL.Simple\",\"package\":\"postgresql-simple\"}],\"nullable\":false},{\"db_type\":\"private_key\",\"haskell_type\":[{\"type\":\"Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString\"},{\"module\":\"Data.ByteString\",\"package\":\"bytestring\"},{\"module\":\"Database.PostgreSQL.Simple\",\"package\":\"postgresql-simple\"}],\"nullable\":false},{\"db_type\":\"check_expr\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.CheckExpr\"},\"nullable\":false},{\"db_type\":\"opcua_type\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaDataValueType\"},\"nullable\":false},{\"db_type\":\"opcua_attribute_value\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaAttributeValue\"},\"nullable\":true},{\"db_type\":\"opcua_attribute_value\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaAttributeValue\"},\"nullable\":false},{\"db_type\":\"opcua_value\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaDataValue\"},\"nullable\":false},{\"db_type\":\"opcua_value\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaDataValue\"},\"nullable\":true},{\"db_type\":\"opcua_attribute_id\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaAttributeId\"},\"nullable\":false},{\"db_type\":\"opcua_attribute_id\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Maybe Pulse.Database.DBTypes.OpcuaAttributeId\"},\"nullable\":true},{\"db_type\":\"opcua_node_id\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaNodeId\"},\"nullable\":false},{\"db_type\":\"opcua_node_id\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Maybe Pulse.Database.DBTypes.OpcuaNodeId\"},\"nullable\":true},{\"db_type\":\"pg_catalog.timestamptz\",\"haskell_type\":{\"module\":\"Data.Time\",\"package\":\"time\",\"type\":\"Maybe Data.Time.UTCTime\"},\"nullable\":true},{\"db_type\":\"pg_catalog.timestamptz\",\"haskell_type\":{\"module\":\"Data.Time\",\"nullable\":false,\"package\":\"time\",\"type\":\"Data.Time.UTCTime\"}},{\"db_type\":\"pg_catalog.interval\",\"haskell_type\":{\"module\":\"Data.Time.LocalTime\",\"package\":\"time\",\"type\":\"Data.Time.LocalTime.CalendarDiffTime\"}},{\"db_type\":\"interval\",\"haskell_type\":{\"module\":\"Data.Time.LocalTime\",\"package\":\"time\",\"type\":\"Data.Time.LocalTime.CalendarDiffTime\"}},{\"db_type\":\"pg_catalog.interval\",\"haskell_type\":{\"module\":\"Data.Time.LocalTime\",\"package\":\"time\",\"type\":\"Maybe Data.Time.LocalTime.CalendarDiffTime\"},\"nullable\":true},{\"db_type\":\"timezone\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Maybe Pulse.Database.DBTypes.Timezone\"},\"nullable\":true},{\"db_type\":\"timezone\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.Timezone\"}}]}" + process { cmd: "dump.sh" } + } +} +catalog { + default_schema: "public" + schemas { + name: "public" + tables { + rel { name: "organizations" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "text" } + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "timezone" } + } + columns { + name: "created_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "logins" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + } + columns { + name: "login_email" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "logins" } + type { name: "timezone" } + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "organization_logins" } + columns { + name: "login_id" + not_null: true + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "role" + not_null: true + length: -1 + table { name: "organization_logins" } + type { name: "organization_role" } + } + columns { + name: "created_at" + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "teams" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "team_members" } + columns { + name: "team_id" + not_null: true + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "login_id" + not_null: true + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "role" + not_null: true + length: -1 + table { name: "team_members" } + type { name: "team_role" } + } + columns { + name: "created_at" + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "monitors" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + } + } + tables { + rel { name: "heartbeat_monitors" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "heartbeat_slug" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "varchar" } + } + columns { + name: "last_heartbeat" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "expected_interval" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "interval" } + } + columns { + name: "created_at" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "opcua_endpoint_credentials" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + } + columns { + name: "username" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + } + columns { + name: "password" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "opcua_endpoint_certificates" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "provided_by" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "certificate_provider" } + } + columns { + name: "subject" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + } + columns { + name: "issuer" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + } + columns { + name: "signature" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + } + columns { + name: "valid_from" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "valid_to" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "certificate" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "x509_certificate" } + } + columns { + name: "private_key" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "private_key" } + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "opcua_endpoint_monitors" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "endpoint" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + } + columns { + name: "mode" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_mode" } + } + columns { + name: "policy" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_policy" } + } + columns { + name: "certificate" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "credentials" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + } + columns { + name: "latest_connection_attempt" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "opcua_node_monitors" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "opcua_node_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "opcua_node_id" } + } + columns { + name: "aggregation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_aggregation" } + } + columns { + name: "operation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_op" } + } + columns { + name: "operand" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + } + columns { + name: "duration" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + } + columns { + name: "frequency" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "opcua_attribute_values" } + columns { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "opcua_node_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_node_id" } + } + columns { + name: "attribute_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_attribute_id" } + } + columns { + name: "value_type" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_type" } + } + columns { + name: "value_integral" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "int8" } + } + columns { + name: "value_float" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "float8" } + } + columns { + name: "value_bool" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "value_string" + length: -1 + table { name: "opcua_attribute_values" } + type { name: "text" } + } + columns { + name: "value_status_code" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "value" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_value" } + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "incidents" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "text" } + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "status" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + } + columns { + name: "lead_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "unacknowledged_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "opcua_endpoint_incidents" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_incidents" } + type { schema: "pg_catalog" name: "int8" } + } + columns { + name: "description_template" + not_null: true + length: -1 + table { name: "opcua_endpoint_incidents" } + type { name: "text" } + } + columns { + name: "opcua_attribute_values" + not_null: true + is_array: true + length: -1 + table { name: "opcua_endpoint_incidents" } + type { name: "opcua_attribute_value" } + array_dims: 1 + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "opcua_node_incidents" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_node_incidents" } + type { schema: "pg_catalog" name: "int8" } + } + columns { + name: "description_template" + not_null: true + length: -1 + table { name: "opcua_node_incidents" } + type { name: "text" } + } + columns { + name: "opcua_attribute_values" + not_null: true + is_array: true + length: -1 + table { name: "opcua_node_incidents" } + type { name: "opcua_attribute_value" } + array_dims: 1 + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_node_incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_node_incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "incident_causes" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_causes" } + type { name: "serial8" } + } + columns { + name: "incident_id" + not_null: true + length: -1 + table { name: "incident_causes" } + type { schema: "pg_catalog" name: "int8" } + } + } + tables { + rel { name: "incident_events" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_events" } + type { name: "serial8" } + } + columns { + name: "incident_id" + not_null: true + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int8" } + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "incident_events" } + type { name: "event_type" } + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "notification_recipients" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "resolved_by" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "created_at" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "severities" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "team_id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "severities" } + type { name: "text" } + } + columns { + name: "notify_by_email" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "notify_by_push" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "created_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "escalation_policies" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + } + columns { + name: "description" + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + } + columns { + name: "is_default" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "escalation_steps" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "step_order" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "delay_interval" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "interval" } + } + columns { + name: "notify_by_email" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "notify_by_push" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "message_template" + length: -1 + table { name: "escalation_steps" } + type { name: "text" } + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "incident_escalations" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int8" } + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "current_step" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "escalation_started_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "next_escalation_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "threshold" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "failed_checks" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "incident_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "resolved_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "acknowledged_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "created_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "escalation_notifications" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "int8" } + } + columns { + name: "incident_escalation_id" + not_null: true + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "int8" } + } + columns { + name: "step_order" + not_null: true + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "notification_channel" + not_null: true + length: -1 + table { name: "escalation_notifications" } + type { name: "text" } + } + columns { + name: "sent_at" + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "delivery_status" + length: -1 + table { name: "escalation_notifications" } + type { name: "text" } + } + columns { + name: "error_message" + length: -1 + table { name: "escalation_notifications" } + type { name: "text" } + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + enums { + name: "organization_role" + vals: "owner" + vals: "admin" + vals: "member" + } + enums { name: "team_role" vals: "admin" vals: "member" } + enums { + name: "monitor_type" + vals: "heartbeat" + vals: "opcua_endpoint" + vals: "opcua_node" + } + enums { + name: "monitor_healthiness" + vals: "unknown" + vals: "healthy" + vals: "suspicious" + vals: "unhealthy" + } + enums { + name: "opcua_security_mode" + vals: "None" + vals: "Sign" + vals: "SignAndEncrypt" + } + enums { + name: "opcua_security_policy" + vals: "None" + vals: "Basic128Rsa15" + vals: "Basic256" + vals: "Basic256Sha256" + vals: "Aes128Sha256RsaOaep" + vals: "Aes256Sha256RsaPss" + } + enums { + name: "certificate_provider" vals: "pulse" vals: "customer" + } + enums { + name: "check_aggregation" + vals: "min" + vals: "max" + vals: "sum" + vals: "avg" + vals: "count" + } + enums { + name: "check_op" + vals: "eq" + vals: "neq" + vals: "lt" + vals: "le" + vals: "gt" + vals: "ge" + } + enums { + name: "incident_status" + vals: "created" + vals: "unacknowledged" + vals: "acknowledged" + vals: "resolved" + } + enums { + name: "event_type" + vals: "incident_started" + vals: "incident_acknowledged" + vals: "incident_resolved" + vals: "monitor_failed" + vals: "monitor_recovered" + vals: "email_notification_sent" + } + } + schemas { name: "pg_temp" } + schemas { + name: "pg_catalog" + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "tid" } + } + columns { + name: "aggfnoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggkind" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "char" } + } + columns { + name: "aggnumdirectargs" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "int2" } + } + columns { + name: "aggtransfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggfinalfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggcombinefn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggserialfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggdeserialfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggmtransfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggminvtransfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggmfinalfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggfinalextra" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "bool" } + } + columns { + name: "aggmfinalextra" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "bool" } + } + columns { + name: "aggfinalmodify" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "char" } + } + columns { + name: "aggmfinalmodify" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "char" } + } + columns { + name: "aggsortop" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "oid" } + } + columns { + name: "aggtranstype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "oid" } + } + columns { + name: "aggtransspace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "int4" } + } + columns { + name: "aggmtranstype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "oid" } + } + columns { + name: "aggmtransspace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "int4" } + } + columns { + name: "agginitval" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "text" } + } + columns { + name: "aggminitval" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "oid" } + } + columns { + name: "amname" + not_null: true + length: 64 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "name" } + } + columns { + name: "amhandler" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "regproc" } + } + columns { + name: "amtype" + not_null: true + length: 1 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "char" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amopfamily" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amoplefttype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amoprighttype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amopstrategy" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "int2" } + } + columns { + name: "amoppurpose" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "char" } + } + columns { + name: "amopopr" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amopmethod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amopsortfamily" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "amprocfamily" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "amproclefttype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "amprocrighttype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "amprocnum" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "int2" } + } + columns { + name: "amproc" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "oid" } + } + columns { + name: "adrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "oid" } + } + columns { + name: "adnum" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "int2" } + } + columns { + name: "adbin" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "tid" } + } + columns { + name: "attrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "oid" } + } + columns { + name: "attname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "name" } + } + columns { + name: "atttypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "oid" } + } + columns { + name: "attstattarget" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "attlen" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int2" } + } + columns { + name: "attnum" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int2" } + } + columns { + name: "attndims" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "attcacheoff" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "atttypmod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "attbyval" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "attalign" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attstorage" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attcompression" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attnotnull" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "atthasdef" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "atthasmissing" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "attidentity" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attgenerated" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attisdropped" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "attislocal" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "attinhcount" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "attcollation" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "oid" } + } + columns { + name: "attacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "_aclitem" } + } + columns { + name: "attoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "_text" } + } + columns { + name: "attfdwoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "_text" } + } + columns { + name: "attmissingval" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "anyarray" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "tid" } + } + columns { + name: "roleid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "oid" } + } + columns { + name: "member" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "oid" } + } + columns { + name: "grantor" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "oid" } + } + columns { + name: "admin_option" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "oid" } + } + columns { + name: "rolname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "name" } + } + columns { + name: "rolsuper" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolinherit" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolcreaterole" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolcreatedb" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolcanlogin" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolreplication" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolbypassrls" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolconnlimit" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "int4" } + } + columns { + name: "rolpassword" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "text" } + } + columns { + name: "rolvaliduntil" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + columns { + name: "name" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "name" } + } + columns { + name: "version" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "text" } + } + columns { + name: "installed" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "bool" } + } + columns { + name: "superuser" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "bool" } + } + columns { + name: "trusted" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "bool" } + } + columns { + name: "relocatable" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "bool" } + } + columns { + name: "schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "name" } + } + columns { + name: "requires" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "_name" } + } + columns { + name: "comment" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + columns { + name: "name" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + type { name: "name" } + } + columns { + name: "default_version" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + type { name: "text" } + } + columns { + name: "installed_version" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + type { name: "text" } + } + columns { + name: "comment" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "text" } + } + columns { + name: "ident" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "text" } + } + columns { + name: "parent" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "text" } + } + columns { + name: "level" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int4" } + } + columns { + name: "total_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + columns { + name: "total_nblocks" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + columns { + name: "free_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + columns { + name: "free_chunks" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + columns { + name: "used_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "castsource" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "casttarget" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "castfunc" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "castcontext" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "char" } + } + columns { + name: "castmethod" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "char" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "name" } + } + columns { + name: "relnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "reltype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "reloftype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relam" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relfilenode" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "reltablespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relpages" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "int4" } + } + columns { + name: "reltuples" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "float4" } + } + columns { + name: "relallvisible" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "int4" } + } + columns { + name: "reltoastrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relhasindex" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relisshared" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relpersistence" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "char" } + } + columns { + name: "relkind" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "char" } + } + columns { + name: "relnatts" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "int2" } + } + columns { + name: "relchecks" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "int2" } + } + columns { + name: "relhasrules" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relhastriggers" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relhassubclass" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relrowsecurity" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relforcerowsecurity" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relispopulated" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relreplident" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "char" } + } + columns { + name: "relispartition" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relrewrite" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relfrozenxid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "xid" } + } + columns { + name: "relminmxid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "xid" } + } + columns { + name: "relacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "_aclitem" } + } + columns { + name: "reloptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "_text" } + } + columns { + name: "relpartbound" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "oid" } + } + columns { + name: "collname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "name" } + } + columns { + name: "collnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "oid" } + } + columns { + name: "collowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "oid" } + } + columns { + name: "collprovider" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "char" } + } + columns { + name: "collisdeterministic" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "bool" } + } + columns { + name: "collencoding" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "int4" } + } + columns { + name: "collcollate" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "text" } + } + columns { + name: "collctype" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "text" } + } + columns { + name: "colliculocale" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "text" } + } + columns { + name: "collversion" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_config" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_config" + } + type { name: "text" } + } + columns { + name: "setting" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_config" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "conname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "name" } + } + columns { + name: "connamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "contype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "char" } + } + columns { + name: "condeferrable" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "condeferred" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "convalidated" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "conrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "contypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "conindid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "conparentid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "confrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "confupdtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "char" } + } + columns { + name: "confdeltype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "char" } + } + columns { + name: "confmatchtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "char" } + } + columns { + name: "conislocal" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "coninhcount" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "int4" } + } + columns { + name: "connoinherit" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "conkey" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_int2" } + } + columns { + name: "confkey" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_int2" } + } + columns { + name: "conpfeqop" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_oid" } + } + columns { + name: "conppeqop" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_oid" } + } + columns { + name: "conffeqop" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_oid" } + } + columns { + name: "confdelsetcols" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_int2" } + } + columns { + name: "conexclop" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_oid" } + } + columns { + name: "conbin" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "oid" } + } + columns { + name: "conname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "name" } + } + columns { + name: "connamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "oid" } + } + columns { + name: "conowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "oid" } + } + columns { + name: "conforencoding" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "int4" } + } + columns { + name: "contoencoding" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "int4" } + } + columns { + name: "conproc" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "regproc" } + } + columns { + name: "condefault" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "text" } + } + columns { + name: "statement" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "text" } + } + columns { + name: "is_holdable" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "bool" } + } + columns { + name: "is_binary" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "bool" } + } + columns { + name: "is_scrollable" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "bool" } + } + columns { + name: "creation_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "oid" } + } + columns { + name: "datname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "name" } + } + columns { + name: "datdba" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "oid" } + } + columns { + name: "encoding" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "int4" } + } + columns { + name: "datlocprovider" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "char" } + } + columns { + name: "datistemplate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "bool" } + } + columns { + name: "datallowconn" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "bool" } + } + columns { + name: "datconnlimit" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "int4" } + } + columns { + name: "datfrozenxid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "xid" } + } + columns { + name: "datminmxid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "xid" } + } + columns { + name: "dattablespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "oid" } + } + columns { + name: "datcollate" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "text" } + } + columns { + name: "datctype" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "text" } + } + columns { + name: "daticulocale" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "text" } + } + columns { + name: "datcollversion" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "text" } + } + columns { + name: "datacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "tid" } + } + columns { + name: "setdatabase" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "oid" } + } + columns { + name: "setrole" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "oid" } + } + columns { + name: "setconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "oid" } + } + columns { + name: "defaclrole" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "oid" } + } + columns { + name: "defaclnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "oid" } + } + columns { + name: "defaclobjtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "char" } + } + columns { + name: "defaclacl" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "tid" } + } + columns { + name: "classid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "objid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "int4" } + } + columns { + name: "refclassid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "refobjid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "refobjsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "int4" } + } + columns { + name: "deptype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "char" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "int4" } + } + columns { + name: "description" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "oid" } + } + columns { + name: "enumtypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "oid" } + } + columns { + name: "enumsortorder" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "float4" } + } + columns { + name: "enumlabel" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "name" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "oid" } + } + columns { + name: "evtname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "name" } + } + columns { + name: "evtevent" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "name" } + } + columns { + name: "evtowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "oid" } + } + columns { + name: "evtfoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "oid" } + } + columns { + name: "evtenabled" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "char" } + } + columns { + name: "evttags" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "oid" } + } + columns { + name: "extname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "name" } + } + columns { + name: "extowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "oid" } + } + columns { + name: "extnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "oid" } + } + columns { + name: "extrelocatable" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "bool" } + } + columns { + name: "extversion" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "text" } + } + columns { + name: "extconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "_oid" } + } + columns { + name: "extcondition" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + columns { + name: "sourcefile" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "text" } + } + columns { + name: "sourceline" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "int4" } + } + columns { + name: "seqno" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "int4" } + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "text" } + } + columns { + name: "setting" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "text" } + } + columns { + name: "applied" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "bool" } + } + columns { + name: "error" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "fdwname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "name" } + } + columns { + name: "fdwowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "fdwhandler" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "fdwvalidator" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "fdwacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "_aclitem" } + } + columns { + name: "fdwoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "oid" } + } + columns { + name: "srvname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "name" } + } + columns { + name: "srvowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "oid" } + } + columns { + name: "srvfdw" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "oid" } + } + columns { + name: "srvtype" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "text" } + } + columns { + name: "srvversion" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "text" } + } + columns { + name: "srvacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "_aclitem" } + } + columns { + name: "srvoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "tid" } + } + columns { + name: "ftrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "oid" } + } + columns { + name: "ftserver" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "oid" } + } + columns { + name: "ftoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "_text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_group" } + columns { + name: "groname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_group" + } + type { name: "name" } + } + columns { + name: "grosysid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_group" + } + type { name: "oid" } + } + columns { + name: "grolist" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_group" + } + type { name: "_oid" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + columns { + name: "line_number" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "int4" } + } + columns { + name: "type" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + columns { + name: "database" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "_text" } + } + columns { + name: "user_name" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "_text" } + } + columns { + name: "address" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + columns { + name: "netmask" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + columns { + name: "auth_method" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + columns { + name: "options" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "_text" } + } + columns { + name: "error" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + columns { + name: "line_number" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "int4" } + } + columns { + name: "map_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "text" } + } + columns { + name: "sys_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "text" } + } + columns { + name: "pg_username" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "text" } + } + columns { + name: "error" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "tid" } + } + columns { + name: "indexrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oid" } + } + columns { + name: "indrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oid" } + } + columns { + name: "indnatts" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "int2" } + } + columns { + name: "indnkeyatts" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "int2" } + } + columns { + name: "indisunique" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indnullsnotdistinct" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisprimary" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisexclusion" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indimmediate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisclustered" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisvalid" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indcheckxmin" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisready" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indislive" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisreplident" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indkey" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "int2vector" } + } + columns { + name: "indcollation" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oidvector" } + } + columns { + name: "indclass" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oidvector" } + } + columns { + name: "indoption" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "int2vector" } + } + columns { + name: "indexprs" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "pg_node_tree" } + } + columns { + name: "indpred" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "name" } + } + columns { + name: "indexname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "name" } + } + columns { + name: "tablespace" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "name" } + } + columns { + name: "indexdef" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "tid" } + } + columns { + name: "inhrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "oid" } + } + columns { + name: "inhparent" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "oid" } + } + columns { + name: "inhseqno" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "int4" } + } + columns { + name: "inhdetachpending" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "int4" } + } + columns { + name: "privtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "char" } + } + columns { + name: "initprivs" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "lanname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "name" } + } + columns { + name: "lanowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "lanispl" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "bool" } + } + columns { + name: "lanpltrusted" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "bool" } + } + columns { + name: "lanplcallfoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "laninline" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "lanvalidator" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "lanacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "tid" } + } + columns { + name: "loid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "oid" } + } + columns { + name: "pageno" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "int4" } + } + columns { + name: "data" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "bytea" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "oid" } + } + columns { + name: "lomowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "oid" } + } + columns { + name: "lomacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "_aclitem" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" } + columns { + name: "locktype" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "text" } + } + columns { + name: "database" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "oid" } + } + columns { + name: "relation" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "oid" } + } + columns { + name: "page" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "int4" } + } + columns { + name: "tuple" + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "int2" } + } + columns { + name: "virtualxid" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "text" } + } + columns { + name: "transactionid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "xid" } + } + columns { + name: "classid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "oid" } + } + columns { + name: "objid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "oid" } + } + columns { + name: "objsubid" + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "int2" } + } + columns { + name: "virtualtransaction" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "text" } + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "int4" } + } + columns { + name: "mode" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "text" } + } + columns { + name: "granted" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "bool" } + } + columns { + name: "fastpath" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "bool" } + } + columns { + name: "waitstart" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "name" } + } + columns { + name: "matviewname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "name" } + } + columns { + name: "matviewowner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "name" } + } + columns { + name: "tablespace" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "name" } + } + columns { + name: "hasindexes" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "bool" } + } + columns { + name: "ispopulated" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "bool" } + } + columns { + name: "definition" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "oid" } + } + columns { + name: "nspname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "name" } + } + columns { + name: "nspowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "oid" } + } + columns { + name: "nspacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcmethod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "name" } + } + columns { + name: "opcnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcfamily" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcintype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcdefault" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "bool" } + } + columns { + name: "opckeytype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "name" } + } + columns { + name: "oprnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprkind" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "char" } + } + columns { + name: "oprcanmerge" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "bool" } + } + columns { + name: "oprcanhash" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "bool" } + } + columns { + name: "oprleft" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprright" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprresult" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprcom" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprnegate" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprcode" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "regproc" } + } + columns { + name: "oprrest" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "regproc" } + } + columns { + name: "oprjoin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + columns { + name: "opfmethod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + columns { + name: "opfname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "name" } + } + columns { + name: "opfnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + columns { + name: "opfowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "oid" } + } + columns { + name: "parname" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "text" } + } + columns { + name: "paracl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "tid" } + } + columns { + name: "partrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oid" } + } + columns { + name: "partstrat" + not_null: true + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "char" } + } + columns { + name: "partnatts" + not_null: true + length: 2 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "int2" } + } + columns { + name: "partdefid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oid" } + } + columns { + name: "partattrs" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "int2vector" } + } + columns { + name: "partclass" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oidvector" } + } + columns { + name: "partcollation" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oidvector" } + } + columns { + name: "partexprs" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "name" } + } + columns { + name: "policyname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "name" } + } + columns { + name: "permissive" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "text" } + } + columns { + name: "roles" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "_name" } + } + columns { + name: "cmd" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "text" } + } + columns { + name: "qual" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "text" } + } + columns { + name: "with_check" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "oid" } + } + columns { + name: "polname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "name" } + } + columns { + name: "polrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "oid" } + } + columns { + name: "polcmd" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "char" } + } + columns { + name: "polpermissive" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "bool" } + } + columns { + name: "polroles" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "_oid" } + } + columns { + name: "polqual" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "pg_node_tree" } + } + columns { + name: "polwithcheck" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "text" } + } + columns { + name: "statement" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "text" } + } + columns { + name: "prepare_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "timestamptz" } + } + columns { + name: "parameter_types" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "_regtype" } + } + columns { + name: "from_sql" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "bool" } + } + columns { + name: "generic_plans" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "int8" } + } + columns { + name: "custom_plans" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + columns { + name: "transaction" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "xid" } + } + columns { + name: "gid" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "text" } + } + columns { + name: "prepared" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "timestamptz" } + } + columns { + name: "owner" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "name" } + } + columns { + name: "database" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "name" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "proname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "name" } + } + columns { + name: "pronamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "proowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "prolang" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "procost" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "float4" } + } + columns { + name: "prorows" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "float4" } + } + columns { + name: "provariadic" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "prosupport" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "regproc" } + } + columns { + name: "prokind" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "char" } + } + columns { + name: "prosecdef" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "bool" } + } + columns { + name: "proleakproof" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "bool" } + } + columns { + name: "proisstrict" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "bool" } + } + columns { + name: "proretset" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "bool" } + } + columns { + name: "provolatile" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "char" } + } + columns { + name: "proparallel" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "char" } + } + columns { + name: "pronargs" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "int2" } + } + columns { + name: "pronargdefaults" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "int2" } + } + columns { + name: "prorettype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "proargtypes" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oidvector" } + } + columns { + name: "proallargtypes" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_oid" } + } + columns { + name: "proargmodes" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_char" } + } + columns { + name: "proargnames" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_text" } + } + columns { + name: "proargdefaults" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "pg_node_tree" } + } + columns { + name: "protrftypes" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_oid" } + } + columns { + name: "prosrc" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "text" } + } + columns { + name: "probin" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "text" } + } + columns { + name: "prosqlbody" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "pg_node_tree" } + } + columns { + name: "proconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_text" } + } + columns { + name: "proacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "oid" } + } + columns { + name: "pubname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "name" } + } + columns { + name: "pubowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "oid" } + } + columns { + name: "puballtables" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubinsert" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubupdate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubdelete" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubtruncate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubviaroot" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "oid" } + } + columns { + name: "pnpubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "oid" } + } + columns { + name: "pnnspid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "oid" } + } + columns { + name: "prpubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "oid" } + } + columns { + name: "prrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "oid" } + } + columns { + name: "prqual" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "pg_node_tree" } + } + columns { + name: "prattrs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "int2vector" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + columns { + name: "pubname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "name" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "name" } + } + columns { + name: "attnames" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "_name" } + } + columns { + name: "rowfilter" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "tid" } + } + columns { + name: "rngtypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngsubtype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngmultitypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngcollation" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngsubopc" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngcanonical" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "regproc" } + } + columns { + name: "rngsubdiff" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "tid" } + } + columns { + name: "roident" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "oid" } + } + columns { + name: "roname" + not_null: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + columns { + name: "local_id" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + type { name: "oid" } + } + columns { + name: "external_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + type { name: "text" } + } + columns { + name: "remote_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + type { name: "pg_lsn" } + } + columns { + name: "local_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + type { name: "pg_lsn" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + columns { + name: "slot_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "name" } + } + columns { + name: "plugin" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "name" } + } + columns { + name: "slot_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "text" } + } + columns { + name: "datoid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "oid" } + } + columns { + name: "database" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "name" } + } + columns { + name: "temporary" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "bool" } + } + columns { + name: "active" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "bool" } + } + columns { + name: "active_pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "int4" } + } + columns { + name: "xmin" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "xid" } + } + columns { + name: "catalog_xmin" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "xid" } + } + columns { + name: "restart_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "pg_lsn" } + } + columns { + name: "confirmed_flush_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "pg_lsn" } + } + columns { + name: "wal_status" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "text" } + } + columns { + name: "safe_wal_size" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "int8" } + } + columns { + name: "two_phase" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "oid" } + } + columns { + name: "rulename" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "name" } + } + columns { + name: "ev_class" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "oid" } + } + columns { + name: "ev_type" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "char" } + } + columns { + name: "ev_enabled" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "char" } + } + columns { + name: "is_instead" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "bool" } + } + columns { + name: "ev_qual" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "pg_node_tree" } + } + columns { + name: "ev_action" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" } + columns { + name: "rolname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "name" } + } + columns { + name: "rolsuper" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolinherit" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolcreaterole" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolcreatedb" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolcanlogin" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolreplication" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolconnlimit" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "int4" } + } + columns { + name: "rolpassword" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "text" } + } + columns { + name: "rolvaliduntil" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "timestamptz" } + } + columns { + name: "rolbypassrls" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "_text" } + } + columns { + name: "oid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "oid" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" + } + type { name: "name" } + } + columns { + name: "rulename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" + } + type { name: "name" } + } + columns { + name: "definition" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "int4" } + } + columns { + name: "provider" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "text" } + } + columns { + name: "label" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + columns { + name: "objoid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "oid" } + } + columns { + name: "classoid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "oid" } + } + columns { + name: "objsubid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "int4" } + } + columns { + name: "objtype" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "text" } + } + columns { + name: "objnamespace" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "oid" } + } + columns { + name: "objname" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "text" } + } + columns { + name: "provider" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "text" } + } + columns { + name: "label" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "tid" } + } + columns { + name: "seqrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "oid" } + } + columns { + name: "seqtypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "oid" } + } + columns { + name: "seqstart" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqincrement" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqmax" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqmin" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqcache" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqcycle" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "name" } + } + columns { + name: "sequencename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "name" } + } + columns { + name: "sequenceowner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "name" } + } + columns { + name: "data_type" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "regtype" } + } + columns { + name: "start_value" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "min_value" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "max_value" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "increment_by" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "cycle" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "bool" } + } + columns { + name: "cache_size" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "last_value" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "setting" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "unit" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "category" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "short_desc" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "extra_desc" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "context" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "vartype" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "source" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "min_val" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "max_val" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "enumvals" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "_text" } + } + columns { + name: "boot_val" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "reset_val" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "sourcefile" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "sourceline" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "int4" } + } + columns { + name: "pending_restart" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "name" } + } + columns { + name: "usesysid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "oid" } + } + columns { + name: "usecreatedb" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "bool" } + } + columns { + name: "usesuper" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "bool" } + } + columns { + name: "userepl" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "bool" } + } + columns { + name: "usebypassrls" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "bool" } + } + columns { + name: "passwd" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "text" } + } + columns { + name: "valuntil" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "timestamptz" } + } + columns { + name: "useconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "tid" } + } + columns { + name: "dbid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "classid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "objid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "int4" } + } + columns { + name: "refclassid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "refobjid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "deptype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "char" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "oid" } + } + columns { + name: "description" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + type { name: "text" } + } + columns { + name: "off" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + type { name: "int8" } + } + columns { + name: "size" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + type { name: "int8" } + } + columns { + name: "allocated_size" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "oid" } + } + columns { + name: "provider" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "text" } + } + columns { + name: "label" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "name" } + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "int4" } + } + columns { + name: "leader_pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "int4" } + } + columns { + name: "usesysid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "oid" } + } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "name" } + } + columns { + name: "application_name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "client_addr" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "inet" } + } + columns { + name: "client_hostname" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "client_port" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "int4" } + } + columns { + name: "backend_start" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "timestamptz" } + } + columns { + name: "xact_start" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "timestamptz" } + } + columns { + name: "query_start" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "timestamptz" } + } + columns { + name: "state_change" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "timestamptz" } + } + columns { + name: "wait_event_type" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "wait_event" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "state" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "backend_xid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "xid" } + } + columns { + name: "backend_xmin" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "xid" } + } + columns { + name: "query_id" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "int8" } + } + columns { + name: "query" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "backend_type" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "name" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_live_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_dead_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_mod_since_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_ins_since_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "last_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autovacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autoanalyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "timestamptz" } + } + columns { + name: "vacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "autovacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "analyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "autoanalyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + columns { + name: "archived_count" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "int8" } + } + columns { + name: "last_archived_wal" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "text" } + } + columns { + name: "last_archived_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "timestamptz" } + } + columns { + name: "failed_count" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "int8" } + } + columns { + name: "last_failed_wal" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "text" } + } + columns { + name: "last_failed_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "timestamptz" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + columns { + name: "checkpoints_timed" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "checkpoints_req" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "checkpoint_write_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "float8" } + } + columns { + name: "checkpoint_sync_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "float8" } + } + columns { + name: "buffers_checkpoint" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "buffers_clean" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "maxwritten_clean" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "buffers_backend" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "buffers_backend_fsync" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "buffers_alloc" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "name" } + } + columns { + name: "numbackends" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int4" } + } + columns { + name: "xact_commit" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "xact_rollback" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_returned" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_fetched" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_inserted" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_updated" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_deleted" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "conflicts" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "temp_files" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "temp_bytes" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "deadlocks" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "checksum_failures" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "checksum_last_failure" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "timestamptz" } + } + columns { + name: "blk_read_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "blk_write_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "session_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "active_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "idle_in_transaction_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "sessions" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "sessions_abandoned" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "sessions_fatal" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "sessions_killed" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "name" } + } + columns { + name: "confl_tablespace" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + columns { + name: "confl_lock" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + columns { + name: "confl_snapshot" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + columns { + name: "confl_bufferpin" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + columns { + name: "confl_deadlock" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + type { name: "int4" } + } + columns { + name: "gss_authenticated" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + type { name: "bool" } + } + columns { + name: "principal" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + type { name: "text" } + } + columns { + name: "encrypted" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "oid" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "text" } + } + columns { + name: "sample_blks_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "sample_blks_scanned" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "ext_stats_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "ext_stats_computed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "child_tables_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "child_tables_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "current_child_table_relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int4" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "text" } + } + columns { + name: "backup_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int8" } + } + columns { + name: "backup_streamed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int8" } + } + columns { + name: "tablespaces_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int8" } + } + columns { + name: "tablespaces_streamed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "oid" } + } + columns { + name: "command" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "text" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "text" } + } + columns { + name: "cluster_index_relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "oid" } + } + columns { + name: "heap_tuples_scanned" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + columns { + name: "heap_tuples_written" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + columns { + name: "heap_blks_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + columns { + name: "heap_blks_scanned" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + columns { + name: "index_rebuild_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "oid" } + } + columns { + name: "command" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "text" } + } + columns { + name: "type" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "text" } + } + columns { + name: "bytes_processed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int8" } + } + columns { + name: "bytes_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int8" } + } + columns { + name: "tuples_processed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int8" } + } + columns { + name: "tuples_excluded" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "oid" } + } + columns { + name: "index_relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "oid" } + } + columns { + name: "command" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "text" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "text" } + } + columns { + name: "lockers_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "lockers_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "current_locker_pid" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "blocks_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "blocks_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "tuples_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "tuples_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "partitions_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "partitions_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "oid" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "text" } + } + columns { + name: "heap_blks_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "heap_blks_scanned" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "heap_blks_vacuumed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "index_vacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "max_dead_tuples" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "num_dead_tuples" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "timestamptz" } + } + columns { + name: "prefetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "skip_init" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "skip_new" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "skip_fpw" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "skip_rep" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "wal_distance" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int4" } + } + columns { + name: "block_distance" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int4" } + } + columns { + name: "io_depth" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int4" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "int4" } + } + columns { + name: "usesysid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "oid" } + } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "name" } + } + columns { + name: "application_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "text" } + } + columns { + name: "client_addr" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "inet" } + } + columns { + name: "client_hostname" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "text" } + } + columns { + name: "client_port" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "int4" } + } + columns { + name: "backend_start" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "timestamptz" } + } + columns { + name: "backend_xmin" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "xid" } + } + columns { + name: "state" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "text" } + } + columns { + name: "sent_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "pg_lsn" } + } + columns { + name: "write_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "pg_lsn" } + } + columns { + name: "flush_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "pg_lsn" } + } + columns { + name: "replay_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "pg_lsn" } + } + columns { + name: "write_lag" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "interval" } + } + columns { + name: "flush_lag" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "interval" } + } + columns { + name: "replay_lag" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "interval" } + } + columns { + name: "sync_priority" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "int4" } + } + columns { + name: "sync_state" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "text" } + } + columns { + name: "reply_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + columns { + name: "slot_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "text" } + } + columns { + name: "spill_txns" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "spill_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "spill_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "stream_txns" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "stream_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "stream_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "total_txns" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "total_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "text" } + } + columns { + name: "blks_zeroed" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "blks_written" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "blks_exists" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "flushes" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "truncates" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "int4" } + } + columns { + name: "ssl" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "bool" } + } + columns { + name: "version" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "text" } + } + columns { + name: "cipher" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "text" } + } + columns { + name: "bits" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "int4" } + } + columns { + name: "client_dn" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "text" } + } + columns { + name: "client_serial" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "numeric" } + } + columns { + name: "issuer_dn" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + columns { + name: "subid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "oid" } + } + columns { + name: "subname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "name" } + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "int4" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "oid" } + } + columns { + name: "received_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "pg_lsn" } + } + columns { + name: "last_msg_send_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "timestamptz" } + } + columns { + name: "last_msg_receipt_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "timestamptz" } + } + columns { + name: "latest_end_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "pg_lsn" } + } + columns { + name: "latest_end_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + columns { + name: "subid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "oid" } + } + columns { + name: "subname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "name" } + } + columns { + name: "apply_error_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "int8" } + } + columns { + name: "sync_error_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "name" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_live_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_dead_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_mod_since_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_ins_since_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "last_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autovacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autoanalyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "timestamptz" } + } + columns { + name: "vacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "autovacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "analyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "autoanalyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + columns { + name: "funcid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "name" } + } + columns { + name: "funcname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "name" } + } + columns { + name: "calls" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "int8" } + } + columns { + name: "total_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "float8" } + } + columns { + name: "self_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "float8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "name" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_live_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_dead_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_mod_since_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_ins_since_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "last_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autovacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autoanalyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "timestamptz" } + } + columns { + name: "vacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "autovacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "analyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "autoanalyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + columns { + name: "wal_records" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_fpi" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_bytes" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "numeric" } + } + columns { + name: "wal_buffers_full" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_write" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_sync" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_write_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "float8" } + } + columns { + name: "wal_sync_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "float8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "int4" } + } + columns { + name: "status" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "text" } + } + columns { + name: "receive_start_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "pg_lsn" } + } + columns { + name: "receive_start_tli" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "int4" } + } + columns { + name: "written_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "pg_lsn" } + } + columns { + name: "flushed_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "pg_lsn" } + } + columns { + name: "received_tli" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "int4" } + } + columns { + name: "last_msg_send_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "timestamptz" } + } + columns { + name: "last_msg_receipt_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "timestamptz" } + } + columns { + name: "latest_end_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "pg_lsn" } + } + columns { + name: "latest_end_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "timestamptz" } + } + columns { + name: "slot_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "text" } + } + columns { + name: "sender_host" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "text" } + } + columns { + name: "sender_port" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "int4" } + } + columns { + name: "conninfo" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + columns { + name: "funcid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "name" } + } + columns { + name: "funcname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "name" } + } + columns { + name: "calls" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "int8" } + } + columns { + name: "total_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "float8" } + } + columns { + name: "self_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "float8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "name" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "name" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "name" } + } + columns { + name: "heap_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "heap_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "name" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "name" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "name" } + } + columns { + name: "heap_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "heap_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "name" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "name" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "name" } + } + columns { + name: "heap_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "heap_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "tid" } + } + columns { + name: "starelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staattnum" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stainherit" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "bool" } + } + columns { + name: "stanullfrac" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "float4" } + } + columns { + name: "stawidth" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int4" } + } + columns { + name: "stadistinct" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "float4" } + } + columns { + name: "stakind1" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stakind2" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stakind3" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stakind4" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stakind5" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "staop1" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staop2" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staop3" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staop4" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staop5" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll1" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll2" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll3" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll4" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll5" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stanumbers1" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stanumbers2" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stanumbers3" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stanumbers4" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stanumbers5" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stavalues1" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + columns { + name: "stavalues2" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + columns { + name: "stavalues3" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + columns { + name: "stavalues4" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + columns { + name: "stavalues5" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "stxrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "stxname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "name" } + } + columns { + name: "stxnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "stxowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "stxstattarget" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "int4" } + } + columns { + name: "stxkeys" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "int2vector" } + } + columns { + name: "stxkind" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "_char" } + } + columns { + name: "stxexprs" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "tid" } + } + columns { + name: "stxoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "oid" } + } + columns { + name: "stxdinherit" + not_null: true + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "bool" } + } + columns { + name: "stxdndistinct" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "pg_ndistinct" } + } + columns { + name: "stxddependencies" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "pg_dependencies" } + } + columns { + name: "stxdmcv" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "pg_mcv_list" } + } + columns { + name: "stxdexpr" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "_pg_statistic" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "name" } + } + columns { + name: "attname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "name" } + } + columns { + name: "inherited" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "bool" } + } + columns { + name: "null_frac" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "float4" } + } + columns { + name: "avg_width" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "int4" } + } + columns { + name: "n_distinct" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "float4" } + } + columns { + name: "most_common_vals" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "anyarray" } + } + columns { + name: "most_common_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "_float4" } + } + columns { + name: "histogram_bounds" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "anyarray" } + } + columns { + name: "correlation" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "float4" } + } + columns { + name: "most_common_elems" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "anyarray" } + } + columns { + name: "most_common_elem_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "_float4" } + } + columns { + name: "elem_count_histogram" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "_float4" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "statistics_schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "statistics_name" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "statistics_owner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "attnames" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_name" } + } + columns { + name: "exprs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_text" } + } + columns { + name: "kinds" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_char" } + } + columns { + name: "inherited" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "bool" } + } + columns { + name: "n_distinct" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "pg_ndistinct" } + } + columns { + name: "dependencies" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "pg_dependencies" } + } + columns { + name: "most_common_vals" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_text" } + } + columns { + name: "most_common_val_nulls" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_bool" } + } + columns { + name: "most_common_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_float8" } + } + columns { + name: "most_common_base_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_float8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "statistics_schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "statistics_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "statistics_owner" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "expr" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "text" } + } + columns { + name: "inherited" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "bool" } + } + columns { + name: "null_frac" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "float4" } + } + columns { + name: "avg_width" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "int4" } + } + columns { + name: "n_distinct" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "float4" } + } + columns { + name: "most_common_vals" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "anyarray" } + } + columns { + name: "most_common_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "_float4" } + } + columns { + name: "histogram_bounds" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "anyarray" } + } + columns { + name: "correlation" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "float4" } + } + columns { + name: "most_common_elems" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "anyarray" } + } + columns { + name: "most_common_elem_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "_float4" } + } + columns { + name: "elem_count_histogram" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "_float4" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "oid" } + } + columns { + name: "subdbid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "oid" } + } + columns { + name: "subskiplsn" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "pg_lsn" } + } + columns { + name: "subname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "name" } + } + columns { + name: "subowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "oid" } + } + columns { + name: "subenabled" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "bool" } + } + columns { + name: "subbinary" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "bool" } + } + columns { + name: "substream" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "bool" } + } + columns { + name: "subtwophasestate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "char" } + } + columns { + name: "subdisableonerr" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "bool" } + } + columns { + name: "subconninfo" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "text" } + } + columns { + name: "subslotname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "name" } + } + columns { + name: "subsynccommit" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "text" } + } + columns { + name: "subpublications" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "tid" } + } + columns { + name: "srsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "oid" } + } + columns { + name: "srrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "oid" } + } + columns { + name: "srsubstate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "char" } + } + columns { + name: "srsublsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "pg_lsn" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "name" } + } + columns { + name: "tableowner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "name" } + } + columns { + name: "tablespace" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "name" } + } + columns { + name: "hasindexes" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "bool" } + } + columns { + name: "hasrules" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "bool" } + } + columns { + name: "hastriggers" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "bool" } + } + columns { + name: "rowsecurity" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "oid" } + } + columns { + name: "spcname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "name" } + } + columns { + name: "spcowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "oid" } + } + columns { + name: "spcacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "_aclitem" } + } + columns { + name: "spcoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_abbrevs" + } + columns { + name: "abbrev" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_abbrevs" + } + type { name: "text" } + } + columns { + name: "utc_offset" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_abbrevs" + } + type { name: "interval" } + } + columns { + name: "is_dst" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_abbrevs" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + type { name: "text" } + } + columns { + name: "abbrev" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + type { name: "text" } + } + columns { + name: "utc_offset" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + type { name: "interval" } + } + columns { + name: "is_dst" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "oid" } + } + columns { + name: "trftype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "oid" } + } + columns { + name: "trflang" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "oid" } + } + columns { + name: "trffromsql" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "regproc" } + } + columns { + name: "trftosql" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgparentid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "name" } + } + columns { + name: "tgfoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgtype" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "int2" } + } + columns { + name: "tgenabled" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "char" } + } + columns { + name: "tgisinternal" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "bool" } + } + columns { + name: "tgconstrrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgconstrindid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgconstraint" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgdeferrable" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "bool" } + } + columns { + name: "tginitdeferred" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "bool" } + } + columns { + name: "tgnargs" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "int2" } + } + columns { + name: "tgattr" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "int2vector" } + } + columns { + name: "tgargs" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "bytea" } + } + columns { + name: "tgqual" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "pg_node_tree" } + } + columns { + name: "tgoldtable" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "name" } + } + columns { + name: "tgnewtable" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "name" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + columns { + name: "cfgname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "name" } + } + columns { + name: "cfgnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + columns { + name: "cfgowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + columns { + name: "cfgparser" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "tid" } + } + columns { + name: "mapcfg" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "oid" } + } + columns { + name: "maptokentype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "int4" } + } + columns { + name: "mapseqno" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "int4" } + } + columns { + name: "mapdict" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "dictname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "name" } + } + columns { + name: "dictnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "dictowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "dicttemplate" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "dictinitoption" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "oid" } + } + columns { + name: "prsname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "name" } + } + columns { + name: "prsnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "oid" } + } + columns { + name: "prsstart" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + columns { + name: "prstoken" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + columns { + name: "prsend" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + columns { + name: "prsheadline" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + columns { + name: "prslextype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "oid" } + } + columns { + name: "tmplname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "name" } + } + columns { + name: "tmplnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "oid" } + } + columns { + name: "tmplinit" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "regproc" } + } + columns { + name: "tmpllexize" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "regproc" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "name" } + } + columns { + name: "typnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typlen" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "int2" } + } + columns { + name: "typbyval" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "bool" } + } + columns { + name: "typtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typcategory" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typispreferred" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "bool" } + } + columns { + name: "typisdefined" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "bool" } + } + columns { + name: "typdelim" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typsubscript" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typelem" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typarray" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typinput" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typoutput" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typreceive" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typsend" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typmodin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typmodout" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typanalyze" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typalign" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typstorage" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typnotnull" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "bool" } + } + columns { + name: "typbasetype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typtypmod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "int4" } + } + columns { + name: "typndims" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "int4" } + } + columns { + name: "typcollation" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typdefaultbin" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "pg_node_tree" } + } + columns { + name: "typdefault" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "text" } + } + columns { + name: "typacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "_aclitem" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "name" } + } + columns { + name: "usesysid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "oid" } + } + columns { + name: "usecreatedb" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "bool" } + } + columns { + name: "usesuper" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "bool" } + } + columns { + name: "userepl" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "bool" } + } + columns { + name: "usebypassrls" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "bool" } + } + columns { + name: "passwd" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "text" } + } + columns { + name: "valuntil" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "timestamptz" } + } + columns { + name: "useconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "oid" } + } + columns { + name: "umuser" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "oid" } + } + columns { + name: "umserver" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "oid" } + } + columns { + name: "umoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + columns { + name: "umid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "srvid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "srvname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "name" } + } + columns { + name: "umuser" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "name" } + } + columns { + name: "umoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "_text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" + } + type { name: "name" } + } + columns { + name: "viewname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" + } + type { name: "name" } + } + columns { + name: "viewowner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" + } + type { name: "name" } + } + columns { + name: "definition" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" + } + type { name: "text" } + } + } + } + schemas { + name: "information_schema" + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + columns { + name: "oid" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "oid" } + } + columns { + name: "fdwowner" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "oid" } + } + columns { + name: "fdwoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "_text" } + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_language" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + columns { + name: "oid" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "oid" } + } + columns { + name: "srvoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "_text" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "character_data" } + } + columns { + name: "foreign_server_version" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "character_data" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + columns { + name: "nspname" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + type { name: "name" } + } + columns { + name: "attname" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + type { name: "name" } + } + columns { + name: "attfdwoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + columns { + name: "foreign_table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "ftoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "_text" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + columns { + name: "oid" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "umoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "_text" } + } + columns { + name: "umuser" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "srvowner" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "administrable_role_authorizations" + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "administrable_role_authorizations" + } + type { name: "sql_identifier" } + } + columns { + name: "role_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "administrable_role_authorizations" + } + type { name: "sql_identifier" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "administrable_role_authorizations" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "applicable_roles" + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "applicable_roles" + } + type { name: "sql_identifier" } + } + columns { + name: "role_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "applicable_roles" + } + type { name: "sql_identifier" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "applicable_roles" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "attribute_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "ordinal_position" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "attribute_default" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "character_data" } + } + columns { + name: "is_nullable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "yes_or_no" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "attribute_udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "attribute_udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "attribute_udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "is_derived_reference_attribute" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "character_repertoire" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "form_of_use" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "default_collate_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "default_collate_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "default_collate_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "check_clause" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + type { name: "sql_identifier" } + } + columns { + name: "pad_attribute" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "dependent_column" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "ordinal_position" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "column_default" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "is_nullable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "is_self_referencing" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + columns { + name: "is_identity" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + columns { + name: "identity_generation" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_start" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_increment" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_maximum" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_minimum" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_cycle" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + columns { + name: "is_generated" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "generation_expression" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "is_updatable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + columns { + name: "object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "character_data" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "is_deferrable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "yes_or_no" } + } + columns { + name: "initially_deferred" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "domain_default" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "character_data" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + columns { + name: "object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "object_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "object_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "character_data" } + } + columns { + name: "collection_type_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "domain_default" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "character_data" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "enabled_roles" + } + columns { + name: "role_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "enabled_roles" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "library_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "character_data" } + } + columns { + name: "foreign_data_wrapper_language" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "character_data" } + } + columns { + name: "foreign_server_version" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "character_data" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + columns { + name: "foreign_table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + columns { + name: "foreign_table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "information_schema_catalog_name" + } + columns { + name: "catalog_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "information_schema_catalog_name" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "ordinal_position" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "cardinal_number" } + } + columns { + name: "position_in_unique_constraint" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "cardinal_number" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "ordinal_position" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "parameter_mode" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "character_data" } + } + columns { + name: "is_result" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "yes_or_no" } + } + columns { + name: "as_locator" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "yes_or_no" } + } + columns { + name: "parameter_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "parameter_default" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "unique_constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "unique_constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "unique_constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "match_option" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "character_data" } + } + columns { + name: "update_rule" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "character_data" } + } + columns { + name: "delete_rule" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "yes_or_no" } + } + columns { + name: "with_hierarchy" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "object_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "object_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "character_data" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "module_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "module_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "module_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "type_udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "type_udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "type_udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_body" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "routine_definition" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "external_name" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "external_language" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "parameter_style" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "is_deterministic" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "sql_data_access" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "is_null_call" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "sql_path" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "schema_level_routine" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "max_dynamic_result_sets" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "is_user_defined_cast" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "is_implicitly_invocable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "security_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "to_sql_specific_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "to_sql_specific_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "to_sql_specific_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "as_locator" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "created" + length: 8 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "time_stamp" } + } + columns { + name: "last_altered" + length: 8 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "time_stamp" } + } + columns { + name: "new_savepoint_level" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "is_udt_dependent" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "result_cast_from_data_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "result_cast_as_locator" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "result_cast_char_max_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_char_octet_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_char_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_char_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_char_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_collation_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_collation_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_collation_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_numeric_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_numeric_scale" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_datetime_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_interval_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "result_cast_interval_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_type_udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_type_udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_type_udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_scope_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_scope_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_scope_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + columns { + name: "catalog_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "schema_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "schema_owner" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "default_character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "default_character_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "default_character_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "sql_path" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + columns { + name: "sequence_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "cardinal_number" } + } + columns { + name: "start_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "minimum_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "maximum_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "increment" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "cycle_option" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "tid" } + } + columns { + name: "feature_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "feature_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "sub_feature_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "sub_feature_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "is_supported" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "yes_or_no" } + } + columns { + name: "is_verified_by" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "comments" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "tid" } + } + columns { + name: "implementation_info_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "character_data" } + } + columns { + name: "implementation_info_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "character_data" } + } + columns { + name: "integer_value" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "cardinal_number" } + } + columns { + name: "character_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "character_data" } + } + columns { + name: "comments" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "tid" } + } + columns { + name: "feature_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "character_data" } + } + columns { + name: "feature_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "character_data" } + } + columns { + name: "is_supported" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "yes_or_no" } + } + columns { + name: "is_verified_by" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "character_data" } + } + columns { + name: "comments" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "tid" } + } + columns { + name: "sizing_id" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "cardinal_number" } + } + columns { + name: "sizing_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "character_data" } + } + columns { + name: "supported_value" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "cardinal_number" } + } + columns { + name: "comments" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "character_data" } + } + columns { + name: "is_deferrable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "yes_or_no" } + } + columns { + name: "initially_deferred" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "yes_or_no" } + } + columns { + name: "enforced" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "yes_or_no" } + } + columns { + name: "nulls_distinct" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "yes_or_no" } + } + columns { + name: "with_hierarchy" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "table_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "character_data" } + } + columns { + name: "self_referencing_column_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "reference_generation" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "character_data" } + } + columns { + name: "user_defined_type_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "is_insertable_into" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "yes_or_no" } + } + columns { + name: "is_typed" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "yes_or_no" } + } + columns { + name: "commit_action" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "group_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "transform_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + columns { + name: "trigger_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "trigger_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "trigger_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_table" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_column" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + columns { + name: "trigger_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "trigger_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "trigger_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "event_manipulation" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "event_object_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_table" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "action_order" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "cardinal_number" } + } + columns { + name: "action_condition" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "action_statement" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "action_orientation" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "action_timing" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "action_reference_old_table" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "action_reference_new_table" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "action_reference_old_row" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "action_reference_new_row" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "created" + length: 8 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "time_stamp" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "character_data" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + columns { + name: "user_defined_type_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_category" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "is_instantiable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "yes_or_no" } + } + columns { + name: "is_final" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "yes_or_no" } + } + columns { + name: "ordering_form" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "ordering_category" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "ordering_routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "ordering_routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "ordering_routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "reference_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "source_dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "ref_dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mappings" + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mappings" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + columns { + name: "view_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "view_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "view_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + columns { + name: "view_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "view_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "view_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "sql_identifier" } + } + columns { + name: "view_definition" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "character_data" } + } + columns { + name: "check_option" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "character_data" } + } + columns { + name: "is_updatable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + columns { + name: "is_insertable_into" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + columns { + name: "is_trigger_updatable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + columns { + name: "is_trigger_deletable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + columns { + name: "is_trigger_insertable_into" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + } + } +} +queries { + text: "SELECT id, display_name, login_email, password_bcrypt, is_deleted, timezone, created_at, updated_at FROM logins\nWHERE id = $1 AND NOT is_deleted" + name: "getLoginById" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "login_email" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_email" + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "logins" } + type { name: "timezone" } + original_name: "timezone" + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, display_name, login_email, password_bcrypt, is_deleted, timezone, created_at, updated_at FROM logins\nWHERE login_email = $1 AND NOT is_deleted" + name: "getLoginByEmail" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "login_email" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_email" + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "logins" } + type { name: "timezone" } + original_name: "timezone" + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "login_email" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_email" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO logins (\n display_name, login_email, password_bcrypt, timezone, is_deleted\n) VALUES ($1, $2, $3, $4, false) RETURNING id" + name: "insertLogin" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + params { + number: 1 + column { + name: "display_name" + length: -1 + table { schema: "public" name: "logins" } + type { name: "text" } + original_name: "display_name" + } + } + params { + number: 2 + column { + name: "login_email" + not_null: true + length: -1 + table { schema: "public" name: "logins" } + type { name: "text" } + original_name: "login_email" + } + } + params { + number: 3 + column { + name: "password_bcrypt" + not_null: true + length: -1 + table { schema: "public" name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + } + params { + number: 4 + column { + name: "timezone" + not_null: true + length: -1 + table { schema: "public" name: "logins" } + type { name: "timezone" } + original_name: "timezone" + } + } + filename: "queries.sql" + insert_into_table { name: "logins" } +} +queries { + text: "SELECT\n logins.id, logins.display_name, logins.login_email, logins.password_bcrypt, logins.is_deleted, logins.timezone, logins.created_at, logins.updated_at,\n organizations.id, organizations.display_name, organizations.timezone, organizations.created_at, organizations.updated_at,\n organization_logins.role\nFROM logins\nINNER JOIN organization_logins ON logins.id = organization_logins.login_id\nINNER JOIN\n organizations\n ON organization_logins.organization_id = organizations.id\nWHERE\n logins.id = $1 AND NOT logins.is_deleted" + name: "getLoginOrganizations" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "login_email" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_email" + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "logins" } + type { name: "timezone" } + original_name: "timezone" + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "timezone" } + original_name: "timezone" + } + columns { + name: "created_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "role" + not_null: true + length: -1 + table { name: "organization_logins" } + type { name: "organization_role" } + original_name: "role" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT\n logins.id, logins.display_name, logins.login_email, logins.password_bcrypt, logins.is_deleted, logins.timezone, logins.created_at, logins.updated_at,\n organizations.id, organizations.display_name, organizations.timezone, organizations.created_at, organizations.updated_at,\n organization_logins.role\nFROM logins\nINNER JOIN organization_logins ON logins.id = organization_logins.login_id\nINNER JOIN\n organizations\n ON organization_logins.organization_id = organizations.id\nWHERE\n logins.id = $1 AND organizations.id = $2 AND NOT logins.is_deleted" + name: "getLoginOrganization" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "login_email" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_email" + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "logins" } + type { name: "timezone" } + original_name: "timezone" + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "timezone" } + original_name: "timezone" + } + columns { + name: "created_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "role" + not_null: true + length: -1 + table { name: "organization_logins" } + type { name: "organization_role" } + original_name: "role" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "integer" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO organization_logins (login_id, organization_id, role) VALUES (\n $1, $2, $3\n) ON CONFLICT (login_id, organization_id) DO NOTHING RETURNING login_id, organization_id, role, created_at, updated_at" + name: "insertOrganizationLogin" + cmd: ":one" + columns { + name: "login_id" + not_null: true + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "login_id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "role" + not_null: true + length: -1 + table { name: "organization_logins" } + type { name: "organization_role" } + original_name: "role" + } + columns { + name: "created_at" + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "login_id" + not_null: true + length: -1 + table { schema: "public" name: "organization_logins" } + type { name: "integer" } + original_name: "login_id" + } + } + params { + number: 2 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "organization_logins" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 3 + column { + name: "role" + not_null: true + length: -1 + table { schema: "public" name: "organization_logins" } + type { name: "organization_role" } + original_name: "role" + } + } + filename: "queries.sql" + insert_into_table { name: "organization_logins" } +} +queries { + text: "SELECT id, display_name, timezone, created_at, updated_at FROM organizations" + name: "getOrganizations" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "timezone" } + original_name: "timezone" + } + columns { + name: "created_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + filename: "queries.sql" +} +queries { + text: "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at\nFROM teams\nWHERE organization_id = $1 AND NOT is_deleted\nORDER BY display_name ASC" + name: "getTeams" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "integer" } + original_name: "organization_id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT teams.id, teams.organization_id, teams.display_name, teams.invitation_code, teams.is_deleted, teams.created_at, teams.updated_at\nFROM logins\nINNER JOIN team_members ON logins.id = team_members.login_id\nINNER JOIN teams ON team_members.team_id = teams.id\nWHERE\n organization_id = $1\n AND logins.id = $2\n AND NOT logins.is_deleted\n AND NOT teams.is_deleted\n AND (\n teams.id IN ($3)\n OR ($3) IS null\n )\nORDER BY teams.display_name ASC" + name: "getLoginTeams" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "integer" } + original_name: "id" + } + } + params { + number: 3 + column { + name: "team_ids" + not_null: true + length: -1 + is_named_param: true + table { name: "teams" } + type { name: "integer" } + is_sqlc_slice: true + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams\nWHERE organization_id = $1 AND id = $2 AND NOT is_deleted" + name: "getTeamById" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT teams.id, organization_id, teams.display_name, invitation_code, is_deleted, teams.created_at, teams.updated_at, organizations.id, organizations.display_name, timezone, organizations.created_at, organizations.updated_at\nFROM teams\nINNER JOIN organizations ON teams.organization_id = organizations.id\nWHERE invitation_code = $1 AND NOT is_deleted" + name: "getTeamByInvitationCode" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "timezone" } + original_name: "timezone" + } + columns { + name: "created_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, display_name, login_email, password_bcrypt, is_deleted, timezone, logins.created_at, logins.updated_at, team_id, login_id, role, team_members.created_at, team_members.updated_at\nFROM logins\nINNER JOIN team_members ON logins.id = team_members.login_id\nWHERE team_id = $1" + name: "getTeamMembers" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "login_email" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_email" + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "timezone" + not_null: true + length: -1 + table { name: "logins" } + type { name: "timezone" } + original_name: "timezone" + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "team_id" + not_null: true + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "int4" } + original_name: "team_id" + } + columns { + name: "login_id" + not_null: true + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "int4" } + original_name: "login_id" + } + columns { + name: "role" + not_null: true + length: -1 + table { name: "team_members" } + type { name: "team_role" } + original_name: "role" + } + columns { + name: "created_at" + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "team_id" + not_null: true + length: -1 + table { name: "team_members" } + type { name: "integer" } + original_name: "team_id" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO team_members (team_id, login_id, role) VALUES (\n $1, $2, $3\n) ON CONFLICT (team_id, login_id) DO NOTHING" + name: "insertTeamMember" + cmd: ":exec" + params { + number: 1 + column { + name: "team_id" + not_null: true + length: -1 + table { schema: "public" name: "team_members" } + type { name: "integer" } + original_name: "team_id" + } + } + params { + number: 2 + column { + name: "login_id" + not_null: true + length: -1 + table { schema: "public" name: "team_members" } + type { name: "integer" } + original_name: "login_id" + } + } + params { + number: 3 + column { + name: "role" + not_null: true + length: -1 + table { schema: "public" name: "team_members" } + type { name: "team_role" } + original_name: "role" + } + } + filename: "queries.sql" + insert_into_table { name: "team_members" } +} +queries { + text: "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams\nWHERE organization_id = $1 AND display_name = $2" + name: "getTeamByName" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO teams (\n organization_id, display_name, invitation_code, is_deleted\n) VALUES ($1, $2, $3, false) RETURNING id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at" + name: "insertTeam" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "teams" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "display_name" + not_null: true + length: -1 + table { schema: "public" name: "teams" } + type { name: "text" } + original_name: "display_name" + } + } + params { + number: 3 + column { + name: "invitation_code" + not_null: true + length: -1 + table { schema: "public" name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + } + filename: "queries.sql" + insert_into_table { name: "teams" } +} +queries { + text: "INSERT INTO teams (\n organization_id, display_name, invitation_code, is_deleted\n) VALUES ($1, $2, $3, false)\nON CONFLICT\n (organization_id, display_name)\n WHERE\n is_deleted = false\nDO UPDATE SET\n updated_at = NOW ()\nRETURNING id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at" + name: "insertDefaultTeamIfNotExists" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "teams" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "display_name" + not_null: true + length: -1 + table { schema: "public" name: "teams" } + type { name: "text" } + original_name: "display_name" + } + } + params { + number: 3 + column { + name: "invitation_code" + not_null: true + length: -1 + table { schema: "public" name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + } + filename: "queries.sql" + insert_into_table { name: "teams" } +} +queries { + text: "SELECT\n incidents.id, incidents.organization_id, incidents.display_name, incidents.description, incidents.failing_monitor, incidents.status, incidents.lead_by, incidents.acknowledged_by, incidents.unacknowledged_at, incidents.created_at, incidents.updated_at,\n monitors.id, monitors.organization_id, monitors.name, monitors.type, monitors.healthiness, monitors.monitor_group, monitors.threshold_failures, monitors.is_active, monitors.is_deleted, monitors.last_checked, monitors.created_at, monitors.updated_at, monitors.escalation_policy_id,\n opcua_endpoint_incidents.id, opcua_endpoint_incidents.description_template, opcua_endpoint_incidents.opcua_attribute_values, opcua_endpoint_incidents.created_at, opcua_endpoint_incidents.updated_at,\n opcua_node_incidents.id, opcua_node_incidents.description_template, opcua_node_incidents.opcua_attribute_values, opcua_node_incidents.created_at, opcua_node_incidents.updated_at\nFROM incidents\nLEFT JOIN monitors ON incidents.failing_monitor = monitors.id\nLEFT JOIN\n opcua_endpoint_incidents\n ON\n monitors.type = \'opcua_endpoint\'\n AND incidents.id = opcua_endpoint_incidents.id\nLEFT JOIN\n opcua_node_incidents\n ON\n monitors.type = \'opcua_node\'\n AND incidents.id = opcua_node_incidents.id\nWHERE\n incidents.organization_id = $1\n AND (\n $2::BIGINT [] IS null\n OR incidents.id = ANY($2::BIGINT [])\n )\n AND status IN ($3)\nORDER BY\n CASE incidents.status\n WHEN \'created\' THEN 1\n WHEN \'unacknowledged\' THEN 2\n WHEN \'acknowledged\' THEN 3\n WHEN \'resolved\' THEN 4\n END ASC,\n incidents.created_at DESC" + name: "getIncidents" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "lead_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "lead_by" + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "acknowledged_by" + } + columns { + name: "unacknowledged_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "unacknowledged_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + length: -1 + table { name: "opcua_endpoint_incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "description_template" + length: -1 + table { name: "opcua_endpoint_incidents" } + type { name: "text" } + original_name: "description_template" + } + columns { + name: "opcua_attribute_values" + is_array: true + length: -1 + table { name: "opcua_endpoint_incidents" } + type { name: "opcua_attribute_value" } + original_name: "opcua_attribute_values" + array_dims: 1 + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + length: -1 + table { name: "opcua_node_incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "description_template" + length: -1 + table { name: "opcua_node_incidents" } + type { name: "text" } + original_name: "description_template" + } + columns { + name: "opcua_attribute_values" + is_array: true + length: -1 + table { name: "opcua_node_incidents" } + type { name: "opcua_attribute_value" } + original_name: "opcua_attribute_values" + array_dims: 1 + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_node_incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_node_incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "incident_ids" + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int8" } + array_dims: 1 + } + } + params { + number: 3 + column { + name: "status" + not_null: true + length: -1 + is_named_param: true + table { name: "incidents" } + type { name: "incident_status" } + is_sqlc_slice: true + original_name: "status" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, updated_at, escalation_policy_id, heartbeat_monitors.id, heartbeat_slug, last_heartbeat, expected_interval, heartbeat_monitors.created_at\nFROM monitors\nINNER JOIN heartbeat_monitors ON monitors.id = heartbeat_monitors.id\nWHERE\n monitors.organization_id = $1\n AND monitors.type = \'heartbeat\'\n AND NOT monitors.is_deleted\n AND (\n $2::TEXT IS null\n OR monitor_group = $2::TEXT\n )" + name: "getHeartbeatMonitors" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "heartbeat_slug" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "varchar" } + original_name: "heartbeat_slug" + } + columns { + name: "last_heartbeat" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_heartbeat" + } + columns { + name: "expected_interval" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "expected_interval" + } + columns { + name: "created_at" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { name: "monitor_group" length: -1 type { name: "text" } } + } + filename: "queries.sql" +} +queries { + text: "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, updated_at, escalation_policy_id, heartbeat_monitors.id, heartbeat_slug, last_heartbeat, expected_interval, heartbeat_monitors.created_at\nFROM\n monitors\nINNER JOIN\n heartbeat_monitors ON monitors.id = heartbeat_monitors.id\nWHERE\n monitors.organization_id = $1\n AND monitors.type = \'heartbeat\'\n AND monitors.is_active\n AND NOT monitors.is_deleted\n AND heartbeat_monitors.last_heartbeat + heartbeat_monitors.expected_interval < NOW()" + name: "getExpiredHeartbeatMonitors" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "heartbeat_slug" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "varchar" } + original_name: "heartbeat_slug" + } + columns { + name: "last_heartbeat" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_heartbeat" + } + columns { + name: "expected_interval" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "expected_interval" + } + columns { + name: "created_at" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, updated_at, escalation_policy_id, heartbeat_monitors.id, heartbeat_slug, last_heartbeat, expected_interval, heartbeat_monitors.created_at\nFROM\n monitors\nINNER JOIN\n heartbeat_monitors ON monitors.id = heartbeat_monitors.id\nWHERE\n monitors.organization_id = $1\n AND monitors.type = \'heartbeat\'\n AND monitors.healthiness IN (\'unknown\', \'unhealthy\')\n AND NOT monitors.is_deleted\n AND heartbeat_monitors.last_heartbeat + heartbeat_monitors.expected_interval >= NOW()" + name: "getRecoveredHeartbearMonitors" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "heartbeat_slug" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "varchar" } + original_name: "heartbeat_slug" + } + columns { + name: "last_heartbeat" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_heartbeat" + } + columns { + name: "expected_interval" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "expected_interval" + } + columns { + name: "created_at" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id\nFROM\n monitors\nWHERE\n monitors.organization_id = $1\n AND\n ( $2::TEXT[] IS NULL\n OR monitors.name = ANY($2::TEXT[])\n )\n AND\n ( $3::INT[] IS NULL\n OR NOT (monitors.id = ANY($3::INT[]))\n )\n AND\n ( $4::INT[] IS NULL\n OR monitors.id = ANY($4::INT[])\n )\n AND NOT monitors.is_deleted" + name: "getMonitors" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "monitor_names" + is_array: true + length: -1 + type { name: "text" } + array_dims: 1 + } + } + params { + number: 3 + column { + name: "exclude_monitors" + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + params { + number: 4 + column { + name: "monitor_ids" + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + filename: "queries.sql" +} +queries { + text: "SELECT monitors.id, monitors.organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_endpoint_monitors.id, endpoint, mode, policy, certificate, credentials, incident_message_template, latest_connection_attempt, opcua_endpoint_monitors.created_at, opcua_endpoint_monitors.updated_at, incidents.id, incidents.organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, incidents.created_at, incidents.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_endpoint_monitors ON monitors.id = opcua_endpoint_monitors.id\nLEFT JOIN\n incidents ON\n incidents.organization_id = monitors.organization_id\n AND incidents.failing_monitor = opcua_endpoint_monitors.id\n AND status <> \'resolved\'\nWHERE\n monitors.organization_id = $1\n AND monitors.type = \'opcua_endpoint\'\n AND\n ( $2::TEXT[] IS NULL\n OR opcua_endpoint_monitors.endpoint = ANY($2::TEXT[])\n )\n AND\n ( $3::INT[] IS NULL\n OR monitors.id = ANY($3::INT[])\n )\n AND\n ( $4::INT[] IS NULL\n OR NOT (monitors.id = ANY($4::INT[]))\n )\n AND NOT monitors.is_deleted" + name: "getOpcuaEndpointMonitors" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "endpoint" + } + columns { + name: "mode" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_mode" } + original_name: "mode" + } + columns { + name: "policy" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_policy" } + original_name: "policy" + } + columns { + name: "certificate" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "certificate" + } + columns { + name: "credentials" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "credentials" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "latest_connection_attempt" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "latest_connection_attempt" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "lead_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "lead_by" + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "acknowledged_by" + } + columns { + name: "unacknowledged_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "unacknowledged_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "endpoints" + is_array: true + length: -1 + type { name: "text" } + array_dims: 1 + } + } + params { + number: 3 + column { + name: "monitor_ids" + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + params { + number: 4 + column { + name: "exclude_monitors" + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + filename: "queries.sql" +} +queries { + text: "SELECT monitors.id, monitors.organization_id, monitors.name, monitors.type, monitors.healthiness, monitors.monitor_group, monitors.threshold_failures, monitors.is_active, monitors.is_deleted, monitors.last_checked, monitors.created_at, monitors.updated_at, monitors.escalation_policy_id, opcua_node_monitors.id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, opcua_node_monitors.created_at, opcua_node_monitors.updated_at, endpoint_monitor.id, endpoint_monitor.organization_id, endpoint_monitor.name, endpoint_monitor.type, endpoint_monitor.healthiness, endpoint_monitor.monitor_group, endpoint_monitor.threshold_failures, endpoint_monitor.is_active, endpoint_monitor.is_deleted, endpoint_monitor.last_checked, endpoint_monitor.created_at, endpoint_monitor.updated_at, endpoint_monitor.escalation_policy_id, incidents.id, incidents.organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, incidents.created_at, incidents.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_node_monitors ON monitors.id = opcua_node_monitors.id\nINNER JOIN\n monitors AS endpoint_monitor ON monitors.id = opcua_node_monitors.endpoint_monitor_id\nLEFT JOIN\n incidents ON\n incidents.organization_id = monitors.organization_id\n AND incidents.failing_monitor = opcua_node_monitors.id\n AND status <> \'resolved\'\nWHERE\n monitors.organization_id = $1\n AND monitors.type = \'opcua_node\'\n AND\n ( $2::INT[] IS NULL\n OR monitors.id = ANY($2::INT[])\n )\n AND\n ( $3::INT[] IS NULL\n OR NOT (monitors.id = ANY($3::INT[]))\n )\n AND NOT monitors.is_deleted" + name: "getOpcuaNodeMonitors" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "endpoint_monitor_id" + } + columns { + name: "opcua_node_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "opcua_node_id" } + original_name: "opcua_node_id" + } + columns { + name: "aggregation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_aggregation" } + original_name: "aggregation" + } + columns { + name: "operation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_op" } + original_name: "operation" + } + columns { + name: "operand" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "operand" + } + columns { + name: "duration" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "duration" + } + columns { + name: "frequency" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "frequency" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "lead_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "lead_by" + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "acknowledged_by" + } + columns { + name: "unacknowledged_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "unacknowledged_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "monitor_ids" + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + params { + number: 3 + column { + name: "exclude_monitors" + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + filename: "queries.sql" +} +queries { + text: "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_endpoint_monitors.id, endpoint, mode, policy, certificate, credentials, incident_message_template, latest_connection_attempt, opcua_endpoint_monitors.created_at, opcua_endpoint_monitors.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_endpoint_monitors ON monitors.id = opcua_endpoint_monitors.id\nWHERE\n monitors.organization_id = $1\n AND monitors.type = \'opcua_endpoint\'\n AND monitors.is_active\n AND NOT monitors.is_deleted\n AND\n (\n monitors.last_checked IS null\n OR monitors.healthiness = \'unknown\'\n OR (\n monitors.healthiness = \'unhealthy\'\n AND monitors.last_checked + \'3 seconds\' < NOW()\n )\n OR (\n monitors.healthiness = \'healthy\'\n AND monitors.last_checked + \'10 seconds\' < NOW()\n )\n )" + name: "getOpcuaEndpointMonitorsToCheck" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "endpoint" + } + columns { + name: "mode" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_mode" } + original_name: "mode" + } + columns { + name: "policy" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_policy" } + original_name: "policy" + } + columns { + name: "certificate" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "certificate" + } + columns { + name: "credentials" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "credentials" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "latest_connection_attempt" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "latest_connection_attempt" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO monitors\n (organization_id, name, type, healthiness, monitor_group, threshold_failures, escalation_policy_id, is_active, is_deleted)\nVALUES\n ($1, $2, $3, \'unknown\', $4, $5, $6, true, false)\nRETURNING id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id" + name: "insertNewMonitor" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "name" + not_null: true + length: -1 + table { schema: "public" name: "monitors" } + type { name: "text" } + original_name: "name" + } + } + params { + number: 3 + column { + name: "type" + not_null: true + length: -1 + table { schema: "public" name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + } + params { + number: 4 + column { + name: "monitor_group" + not_null: true + length: -1 + table { schema: "public" name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + } + params { + number: 5 + column { + name: "threshold_failures" + not_null: true + length: -1 + table { schema: "public" name: "monitors" } + type { name: "integer" } + original_name: "threshold_failures" + } + } + params { + number: 6 + column { + name: "escalation_policy_id" + not_null: true + length: -1 + table { schema: "public" name: "monitors" } + type { name: "integer" } + original_name: "escalation_policy_id" + } + } + filename: "queries.sql" + insert_into_table { name: "monitors" } +} +queries { + text: "UPDATE\n monitors\nSET\n name = COALESCE($2::TEXT, monitors.name),\n threshold_failures = COALESCE($3::INTEGER, monitors.threshold_failures),\n healthiness = COALESCE($4::monitor_healthiness, monitors.healthiness),\n last_checked = NULL,\n updated_at = NOW()\nWHERE\n monitors.id = $1\nRETURNING id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id" + name: "updateMonitor" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "id" + } + } + params { + number: 2 column { name: "name" length: -1 type { name: "text" } } + } + params { + number: 3 + column { + name: "threshold_failures" + length: -1 + type { schema: "pg_catalog" name: "int4" } + } + } + params { + number: 4 + column { + name: "healthiness" length: -1 type { name: "monitor_healthiness" } + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE\n monitors\nSET\n is_active = false,\n updated_at = NOW()\nWHERE\n monitors.id = $1" + name: "pauseMonitor" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE\n monitors\nSET\n is_active = true,\n updated_at = NOW()\nWHERE\n monitors.id = $1" + name: "unpauseMonitor" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT\n id, organization_id, name, username, password, created_at, updated_at\nFROM\n opcua_endpoint_credentials\nWHERE\n organization_id = $1\n AND\n ( $2::INT[] IS NULL\n OR opcua_endpoint_credentials.id = ANY($2::INT [])\n )" + name: "getOpcuaEndpointCredentials" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "name" + } + columns { + name: "username" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "username" + } + columns { + name: "password" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "password" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "credential_ids" + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO opcua_endpoint_credentials\n (organization_id, name, username, password)\nVALUES\n ($1, $2, $3, $4)\nON CONFLICT\n (organization_id, name)\nDO UPDATE SET\n updated_at = NOW ()\nRETURNING id, organization_id, name, username, password, created_at, updated_at" + name: "insertOpcuaEndpointCredentials" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "name" + } + columns { + name: "username" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "username" + } + columns { + name: "password" + not_null: true + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "password" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_credentials" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "name" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "name" + } + } + params { + number: 3 + column { + name: "username" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "username" + } + } + params { + number: 4 + column { + name: "password" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "password" + } + } + filename: "queries.sql" + insert_into_table { name: "opcua_endpoint_credentials" } +} +queries { + text: "SELECT\n id, organization_id, provided_by, subject, issuer, signature, valid_from, valid_to, certificate, private_key, created_at, updated_at\nFROM\n opcua_endpoint_certificates\nWHERE\n organization_id = $1\n AND\n ( $2::INT[] IS NULL\n OR opcua_endpoint_certificates.id = ANY($2::INT [])\n )" + name: "getOpcuaEndpointCertificates" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "provided_by" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "certificate_provider" } + original_name: "provided_by" + } + columns { + name: "subject" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "subject" + } + columns { + name: "issuer" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "issuer" + } + columns { + name: "signature" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "signature" + } + columns { + name: "valid_from" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "valid_from" + } + columns { + name: "valid_to" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "valid_to" + } + columns { + name: "certificate" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "x509_certificate" } + original_name: "certificate" + } + columns { + name: "private_key" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "private_key" } + original_name: "private_key" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "certificate_ids" + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO opcua_endpoint_certificates\n (organization_id, provided_by, subject, issuer, signature, valid_from, valid_to, certificate, private_key)\nVALUES\n ($1, $2, $3, $4, $5, $6, $7, $8, $9)\nON CONFLICT\n (organization_id, signature)\nDO UPDATE SET\n updated_at = NOW ()\nRETURNING id, organization_id, provided_by, subject, issuer, signature, valid_from, valid_to, certificate, private_key, created_at, updated_at" + name: "insertOpcuaEndpointCertificate" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "provided_by" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "certificate_provider" } + original_name: "provided_by" + } + columns { + name: "subject" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "subject" + } + columns { + name: "issuer" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "issuer" + } + columns { + name: "signature" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "signature" + } + columns { + name: "valid_from" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "valid_from" + } + columns { + name: "valid_to" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "valid_to" + } + columns { + name: "certificate" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "x509_certificate" } + original_name: "certificate" + } + columns { + name: "private_key" + not_null: true + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "private_key" } + original_name: "private_key" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_certificates" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "provided_by" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_certificates" } + type { name: "certificate_provider" } + original_name: "provided_by" + } + } + params { + number: 3 + column { + name: "subject" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "subject" + } + } + params { + number: 4 + column { + name: "issuer" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "issuer" + } + } + params { + number: 5 + column { + name: "signature" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "signature" + } + } + params { + number: 6 + column { + name: "valid_from" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_certificates" } + type { name: "pg_catalog.timestamptz" } + original_name: "valid_from" + } + } + params { + number: 7 + column { + name: "valid_to" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_certificates" } + type { name: "pg_catalog.timestamptz" } + original_name: "valid_to" + } + } + params { + number: 8 + column { + name: "certificate" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_certificates" } + type { name: "x509_certificate" } + original_name: "certificate" + } + } + params { + number: 9 + column { + name: "private_key" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_certificates" } + type { name: "private_key" } + original_name: "private_key" + } + } + filename: "queries.sql" + insert_into_table { name: "opcua_endpoint_certificates" } +} +queries { + text: "INSERT INTO opcua_endpoint_monitors\n (id, endpoint, mode, policy, certificate, credentials, incident_message_template)\nVALUES\n ($1, $2, $3, $4, $5, $6, $7)\nRETURNING id, endpoint, mode, policy, certificate, credentials, incident_message_template, latest_connection_attempt, created_at, updated_at" + name: "insertNewOpcuaEndpointMonitor" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "endpoint" + } + columns { + name: "mode" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_mode" } + original_name: "mode" + } + columns { + name: "policy" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_policy" } + original_name: "policy" + } + columns { + name: "certificate" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "certificate" + } + columns { + name: "credentials" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "credentials" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "latest_connection_attempt" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "latest_connection_attempt" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "integer" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "endpoint" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "endpoint" + } + } + params { + number: 3 + column { + name: "mode" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "opcua_security_mode" } + original_name: "mode" + } + } + params { + number: 4 + column { + name: "policy" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "opcua_security_policy" } + original_name: "policy" + } + } + params { + number: 5 + column { + name: "certificate" + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "integer" } + original_name: "certificate" + } + } + params { + number: 6 + column { + name: "credentials" + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "integer" } + original_name: "credentials" + } + } + params { + number: 7 + column { + name: "incident_message_template" + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + } + filename: "queries.sql" + insert_into_table { name: "opcua_endpoint_monitors" } +} +queries { + text: "UPDATE\n opcua_endpoint_monitors\nSET\n endpoint = $1,\n mode = $2,\n policy = $3,\n certificate = $4,\n credentials = $5,\n incident_message_template = $6,\n updated_at = NOW()\nWHERE\n opcua_endpoint_monitors.id = $7\nRETURNING id, endpoint, mode, policy, certificate, credentials, incident_message_template, latest_connection_attempt, created_at, updated_at" + name: "updateNewOpcuaEndpointMonitor" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "endpoint" + } + columns { + name: "mode" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_mode" } + original_name: "mode" + } + columns { + name: "policy" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_policy" } + original_name: "policy" + } + columns { + name: "certificate" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "certificate" + } + columns { + name: "credentials" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "credentials" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "latest_connection_attempt" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "latest_connection_attempt" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "endpoint" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "endpoint" + } + } + params { + number: 2 + column { + name: "mode" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "opcua_security_mode" } + original_name: "mode" + } + } + params { + number: 3 + column { + name: "policy" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "opcua_security_policy" } + original_name: "policy" + } + } + params { + number: 4 + column { + name: "certificate" + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "integer" } + original_name: "certificate" + } + } + params { + number: 5 + column { + name: "credentials" + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "integer" } + original_name: "credentials" + } + } + params { + number: 6 + column { + name: "incident_message_template" + length: -1 + table { schema: "public" name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + } + params { + number: 7 + column { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO opcua_node_monitors\n (id, endpoint_monitor_id, opcua_node_id, aggregation, operand, operation, duration, frequency, incident_message_template)\nVALUES\n ($1, $2, $3, $4, $5, $6, $7, $8, $9)\nRETURNING id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, created_at, updated_at" + name: "insertOpcuaNodeMonitor" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "endpoint_monitor_id" + } + columns { + name: "opcua_node_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "opcua_node_id" } + original_name: "opcua_node_id" + } + columns { + name: "aggregation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_aggregation" } + original_name: "aggregation" + } + columns { + name: "operation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_op" } + original_name: "operation" + } + columns { + name: "operand" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "operand" + } + columns { + name: "duration" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "duration" + } + columns { + name: "frequency" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "frequency" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_monitors" } + type { name: "integer" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_monitors" } + type { name: "integer" } + original_name: "endpoint_monitor_id" + } + } + params { + number: 3 + column { + name: "opcua_node_id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_monitors" } + type { name: "opcua_node_id" } + original_name: "opcua_node_id" + } + } + params { + number: 4 + column { + name: "aggregation" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_monitors" } + type { name: "check_aggregation" } + original_name: "aggregation" + } + } + params { + number: 5 + column { + name: "operand" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_monitors" } + type { name: "text" } + original_name: "operand" + } + } + params { + number: 6 + column { + name: "operation" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_monitors" } + type { name: "check_op" } + original_name: "operation" + } + } + params { + number: 7 + column { + name: "duration" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_monitors" } + type { name: "interval" } + original_name: "duration" + } + } + params { + number: 8 + column { + name: "frequency" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_monitors" } + type { name: "interval" } + original_name: "frequency" + } + } + params { + number: 9 + column { + name: "incident_message_template" + length: -1 + table { schema: "public" name: "opcua_node_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + } + filename: "queries.sql" + insert_into_table { name: "opcua_node_monitors" } +} +queries { + text: "UPDATE opcua_node_monitors\nSET\n endpoint_monitor_id = COALESCE($2::INT, opcua_node_monitors.endpoint_monitor_id),\n opcua_node_id = COALESCE($3::opcua_node_id, opcua_node_monitors.opcua_node_id),\n aggregation = COALESCE($4::check_aggregation, opcua_node_monitors.aggregation),\n operand = COALESCE($5::TEXT, opcua_node_monitors.operand),\n operation = COALESCE($6::check_op, opcua_node_monitors.operation),\n duration = COALESCE($7::INTERVAL, opcua_node_monitors.duration),\n frequency = COALESCE($8::INTERVAL, opcua_node_monitors.frequency),\n incident_message_template = COALESCE($9::TEXT, opcua_node_monitors.incident_message_template)\nWHERE id = $1\nRETURNING id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, created_at, updated_at" + name: "updateOpcuaNodeMonitor" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "endpoint_monitor_id" + } + columns { + name: "opcua_node_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "opcua_node_id" } + original_name: "opcua_node_id" + } + columns { + name: "aggregation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_aggregation" } + original_name: "aggregation" + } + columns { + name: "operation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_op" } + original_name: "operation" + } + columns { + name: "operand" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "operand" + } + columns { + name: "duration" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "duration" + } + columns { + name: "frequency" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "frequency" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "integer" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "endpoint_monitor_id" + length: -1 + type { schema: "pg_catalog" name: "int4" } + } + } + params { + number: 3 + column { + name: "opcua_node_id" length: -1 type { name: "opcua_node_id" } + } + } + params { + number: 4 + column { + name: "aggregation" length: -1 type { name: "check_aggregation" } + } + } + params { + number: 5 + column { name: "operand" length: -1 type { name: "text" } } + } + params { + number: 6 + column { name: "operation" length: -1 type { name: "check_op" } } + } + params { + number: 7 + column { + name: "duration" + length: -1 + type { schema: "pg_catalog" name: "interval" } + } + } + params { + number: 8 + column { + name: "frequency" + length: -1 + type { schema: "pg_catalog" name: "interval" } + } + } + params { + number: 9 + column { + name: "incident_message_template" length: -1 type { name: "text" } + } + } + filename: "queries.sql" +} +queries { + text: "SELECT monitors.id, monitors.organization_id, monitors.name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_endpoint_monitors.id, endpoint, mode, policy, opcua_endpoint_monitors.certificate, credentials, incident_message_template, latest_connection_attempt, opcua_endpoint_monitors.created_at, opcua_endpoint_monitors.updated_at, opcua_endpoint_credentials.id, opcua_endpoint_credentials.organization_id, opcua_endpoint_credentials.name, username, password, opcua_endpoint_credentials.created_at, opcua_endpoint_credentials.updated_at, opcua_endpoint_certificates.id, opcua_endpoint_certificates.organization_id, provided_by, subject, issuer, signature, valid_from, valid_to, opcua_endpoint_certificates.certificate, private_key, opcua_endpoint_certificates.created_at, opcua_endpoint_certificates.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_endpoint_monitors ON monitors.id = opcua_endpoint_monitors.id\nLEFT JOIN\n opcua_endpoint_credentials ON monitors.id = opcua_endpoint_credentials.id\nLEFT JOIN\n opcua_endpoint_certificates ON monitors.id = opcua_endpoint_certificates.id\nWHERE\n monitors.organization_id = $1\n AND monitors.type = \'opcua_endpoint\'\n -- We used to only sample \"active\" endpoints. We continue to sample active\n -- OPCUA Endpoints but we do not raise any incidents for them, if they are\n -- failing.\n --\n -- AND monitors.is_active\n AND NOT monitors.is_deleted" + name: "getOpcuaEndpointMonitorsToSample" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "endpoint" + } + columns { + name: "mode" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_mode" } + original_name: "mode" + } + columns { + name: "policy" + not_null: true + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "opcua_security_policy" } + original_name: "policy" + } + columns { + name: "certificate" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "certificate" + } + columns { + name: "credentials" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "credentials" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "latest_connection_attempt" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "latest_connection_attempt" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "name" + } + columns { + name: "username" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "username" + } + columns { + name: "password" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { name: "text" } + original_name: "password" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_credentials" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "provided_by" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "certificate_provider" } + original_name: "provided_by" + } + columns { + name: "subject" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "subject" + } + columns { + name: "issuer" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "issuer" + } + columns { + name: "signature" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "text" } + original_name: "signature" + } + columns { + name: "valid_from" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "valid_from" + } + columns { + name: "valid_to" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "valid_to" + } + columns { + name: "certificate" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "x509_certificate" } + original_name: "certificate" + } + columns { + name: "private_key" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { name: "private_key" } + original_name: "private_key" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_endpoint_certificates" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_node_monitors.id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, opcua_node_monitors.created_at, opcua_node_monitors.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_node_monitors ON monitors.id = opcua_node_monitors.id\nWHERE\n monitors.organization_id = $1\n AND monitors.type = \'opcua_node\'\n AND NOT monitors.is_deleted\n -- We used to only sample \"active\" endpoints. We continue to sample active\n -- OPCUA Endpoints but we do not raise any incidents for them, if they are\n -- failing.\n --\n -- AND monitors.is_active\n AND opcua_node_monitors.endpoint_monitor_id IN ($2)" + name: "getOpcuaNodeMonitorsToSample" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "endpoint_monitor_id" + } + columns { + name: "opcua_node_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "opcua_node_id" } + original_name: "opcua_node_id" + } + columns { + name: "aggregation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_aggregation" } + original_name: "aggregation" + } + columns { + name: "operation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_op" } + original_name: "operation" + } + columns { + name: "operand" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "operand" + } + columns { + name: "duration" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "duration" + } + columns { + name: "frequency" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "frequency" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "endpoint_monitor_ids" + not_null: true + length: -1 + is_named_param: true + table { name: "opcua_node_monitors" } + type { name: "integer" } + is_sqlc_slice: true + original_name: "endpoint_monitor_id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_node_monitors.id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, opcua_node_monitors.created_at, opcua_node_monitors.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_node_monitors ON monitors.id = opcua_node_monitors.id\nWHERE\n monitors.organization_id = $1\n AND monitors.type = \'opcua_node\'\n AND monitors.is_active\n AND NOT monitors.is_deleted\n AND opcua_node_monitors.endpoint_monitor_id IN ($2)\n AND\n ( COALESCE ($3::BOOLEAN, false)\n OR monitors.last_checked IS NULL\n OR monitors.last_checked + opcua_node_monitors.frequency <= NOW ()\n )" + name: "getOpcuaNodeMonitorsToCheck" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "endpoint_monitor_id" + } + columns { + name: "opcua_node_id" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "opcua_node_id" } + original_name: "opcua_node_id" + } + columns { + name: "aggregation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_aggregation" } + original_name: "aggregation" + } + columns { + name: "operation" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "check_op" } + original_name: "operation" + } + columns { + name: "operand" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "operand" + } + columns { + name: "duration" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "duration" + } + columns { + name: "frequency" + not_null: true + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "frequency" + } + columns { + name: "incident_message_template" + length: -1 + table { name: "opcua_node_monitors" } + type { name: "text" } + original_name: "incident_message_template" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "opcua_node_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "endpoint_monitor_ids" + not_null: true + length: -1 + is_named_param: true + table { name: "opcua_node_monitors" } + type { name: "integer" } + is_sqlc_slice: true + original_name: "endpoint_monitor_id" + } + } + params { + number: 3 + column { + name: "override" + length: -1 + type { schema: "pg_catalog" name: "bool" } + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO opcua_attribute_values\n( endpoint_monitor_id,\n attribute_id,\n opcua_node_id,\n value_type,\n value_integral,\n value_float,\n value_bool,\n value_string,\n value_status_code,\n value\n)\nVALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)" + name: "insertOpcuaAttributeValue" + cmd: ":exec" + params { + number: 1 + column { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "integer" } + original_name: "endpoint_monitor_id" + } + } + params { + number: 2 + column { + name: "attribute_id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "opcua_attribute_id" } + original_name: "attribute_id" + } + } + params { + number: 3 + column { + name: "opcua_node_id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "opcua_node_id" } + original_name: "opcua_node_id" + } + } + params { + number: 4 + column { + name: "value_type" + not_null: true + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "opcua_type" } + original_name: "value_type" + } + } + params { + number: 5 + column { + name: "value_integral" + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "bigint" } + original_name: "value_integral" + } + } + params { + number: 6 + column { + name: "value_float" + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "double precision" } + original_name: "value_float" + } + } + params { + number: 7 + column { + name: "value_bool" + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "boolean" } + original_name: "value_bool" + } + } + params { + number: 8 + column { + name: "value_string" + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "text" } + original_name: "value_string" + } + } + params { + number: 9 + column { + name: "value_status_code" + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "integer" } + original_name: "value_status_code" + } + } + params { + number: 10 + column { + name: "value" + not_null: true + length: -1 + table { schema: "public" name: "opcua_attribute_values" } + type { name: "opcua_value" } + original_name: "value" + } + } + filename: "queries.sql" + insert_into_table { name: "opcua_attribute_values" } +} +queries { + text: "SELECT DISTINCT ON (endpoint_monitor_id, attribute_id, opcua_node_id)\n endpoint_monitor_id,\n attribute_id,\n opcua_node_id,\n value_type,\n value,\n created_at,\n (NOW() - created_at)::INTERVAL AS age\nFROM\n opcua_attribute_values\nWHERE\n endpoint_monitor_id = ANY($1::INTEGER [])\n AND opcua_node_id = ANY($2::OPCUA_NODE_ID [])\n AND attribute_id = ANY($3::OPCUA_ATTRIBUTE_ID [])\nORDER BY\n endpoint_monitor_id ASC,\n attribute_id ASC,\n opcua_node_id ASC,\n created_at DESC" + name: "getLatestSampledOpcuaAttributeValues" + cmd: ":many" + columns { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "int4" } + original_name: "endpoint_monitor_id" + } + columns { + name: "attribute_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_attribute_id" } + original_name: "attribute_id" + } + columns { + name: "opcua_node_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_node_id" } + original_name: "opcua_node_id" + } + columns { + name: "value_type" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_type" } + original_name: "value_type" + } + columns { + name: "value" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_value" } + original_name: "value" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "age" + not_null: true + length: -1 + type { schema: "pg_catalog" name: "interval" } + } + params { + number: 1 + column { + name: "endpoint_monitor_ids" + not_null: true + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + params { + number: 2 + column { + name: "node_ids" + not_null: true + is_array: true + length: -1 + type { name: "opcua_node_id" } + array_dims: 1 + } + } + params { + number: 3 + column { + name: "attribute_ids" + not_null: true + is_array: true + length: -1 + type { name: "opcua_attribute_id" } + array_dims: 1 + } + } + filename: "queries.sql" +} +queries { + text: "SELECT\n inputs.monitor_id,\n\n aggregates.count,\n\n aggregates.min_value_integral,\n aggregates.max_value_integral,\n aggregates.avg_value_integral,\n aggregates.sum_value_integral,\n\n aggregates.min_value_float,\n aggregates.max_value_float,\n aggregates.avg_value_float,\n aggregates.sum_value_float\nFROM\n -- SQLC doesn\'t have a good way to pass many structured things\n -- so instead we pass a bunch of arrays which are hopefully all\n -- have the same length.\n ( SELECT\n unnest($1::INT[]) as monitor_id,\n unnest($2::INT[]) as endpoint_monitor_id,\n unnest($3::OPCUA_NODE_ID[]) as node_id,\n unnest($4::OPCUA_ATTRIBUTE_ID[]) as attribute_id,\n unnest($5::INTERVAL[]) as duration_start,\n unnest($6::INTERVAL[]) as duration_end\n ) AS inputs,\nLATERAL\n ( SELECT\n COUNT(*) as count,\n -- This looks strange but is necessary to make SQLC do the right\n -- thing, that is mark the aggregates as nullable.\n COALESCE(NULL, MIN(value_integral)) AS min_value_integral,\n COALESCE(NULL, MAX(value_integral)) AS max_value_integral,\n COALESCE(NULL, AVG(value_integral)) AS avg_value_integral,\n COALESCE(NULL, SUM(value_integral)) AS sum_value_integral,\n\n COALESCE(NULL, MIN(value_float)) AS min_value_float,\n COALESCE(NULL, MAX(value_float)) AS max_value_float,\n COALESCE(NULL, AVG(value_float)) AS avg_value_float,\n COALESCE(NULL, SUM(value_float)) AS sum_value_float\n FROM\n opcua_attribute_values\n WHERE\n opcua_attribute_values.endpoint_monitor_id = inputs.endpoint_monitor_id\n AND opcua_attribute_values.opcua_node_id = inputs.node_id\n AND opcua_attribute_values.attribute_id = inputs.attribute_id\n AND created_at >= NOW() - inputs.duration_start\n AND created_at < NOW () - inputs.duration_end\n LIMIT 1\n ) AS aggregates" + name: "getOpcuaAttributeAggregates" + cmd: ":many" + columns { + name: "monitor_id" + not_null: true + length: -1 + type { name: "integer" } + original_name: "monitor_id" + } + columns { + name: "count" + not_null: true + length: -1 + type { name: "bigint" } + original_name: "count" + } + columns { + name: "min_value_integral" + length: -1 + type { name: "bigint" } + original_name: "min_value_integral" + } + columns { + name: "max_value_integral" + length: -1 + type { name: "bigint" } + original_name: "max_value_integral" + } + columns { + name: "avg_value_integral" + length: -1 + type { name: "numeric" } + original_name: "avg_value_integral" + } + columns { + name: "sum_value_integral" + length: -1 + type { name: "numeric" } + original_name: "sum_value_integral" + } + columns { + name: "min_value_float" + length: -1 + type { name: "double precision" } + original_name: "min_value_float" + } + columns { + name: "max_value_float" + length: -1 + type { name: "double precision" } + original_name: "max_value_float" + } + columns { + name: "avg_value_float" + length: -1 + type { name: "double precision" } + original_name: "avg_value_float" + } + columns { + name: "sum_value_float" + length: -1 + type { name: "double precision" } + original_name: "sum_value_float" + } + params { + number: 1 + column { + name: "monitor_ids" + not_null: true + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + params { + number: 2 + column { + name: "endpoint_monitor_ids" + not_null: true + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + params { + number: 3 + column { + name: "node_ids" + not_null: true + is_array: true + length: -1 + type { name: "opcua_node_id" } + array_dims: 1 + } + } + params { + number: 4 + column { + name: "attribute_ids" + not_null: true + is_array: true + length: -1 + type { name: "opcua_attribute_id" } + array_dims: 1 + } + } + params { + number: 5 + column { + name: "duration_starts" + not_null: true + is_array: true + length: -1 + type { schema: "pg_catalog" name: "interval" } + array_dims: 1 + } + } + params { + number: 6 + column { + name: "duration_ends" + not_null: true + is_array: true + length: -1 + type { schema: "pg_catalog" name: "interval" } + array_dims: 1 + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE\n monitors\nSET\n is_deleted = true\nWHERE\n organization_id = $1\n AND id = $2" + name: "deleteMonitor" + cmd: ":exec" + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE\n monitors\nSET\n healthiness = \'healthy\',\n last_checked = NOW(),\n updated_at = NOW()\nWHERE\n monitors.id IN ($1)\nRETURNING id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id" + name: "flopMonitorHealthiness" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + params { + number: 1 + column { + name: "monitor_ids" + not_null: true + length: -1 + is_named_param: true + table { name: "monitors" } + type { name: "integer" } + is_sqlc_slice: true + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE\n monitors\nSET\n healthiness = \'unhealthy\'::monitor_healthiness,\n last_checked = NOW(),\n updated_at = NOW()\nWHERE\n monitors.id IN ($1)\nRETURNING id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id" + name: "flipMonitorHealthiness" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + params { + number: 1 + column { + name: "monitor_ids" + not_null: true + length: -1 + is_named_param: true + table { name: "monitors" } + type { name: "integer" } + is_sqlc_slice: true + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "WITH opcua_endpoint_incidents AS (\n INSERT INTO\n opcua_endpoint_incidents (id, description_template, opcua_attribute_values)\n VALUES ($1, $2, $3)\n ON CONFLICT (id) DO NOTHING\n RETURNING id, description_template, opcua_attribute_values, created_at, updated_at\n),\nmonitor_failed_event AS (\n INSERT INTO\n incident_events (incident_id, type, failing_monitor)\n SELECT\n opcua_endpoint_incidents.id, \'monitor_failed\', incidents.failing_monitor\n FROM\n opcua_endpoint_incidents JOIN incidents ON opcua_endpoint_incidents.id = incidents.id\n)\nINSERT INTO\n incident_events (incident_id, type)\nSELECT\n opcua_endpoint_incidents.id, \'incident_started\'\nFROM\n opcua_endpoint_incidents JOIN incidents ON opcua_endpoint_incidents.id = incidents.id" + name: "createOpcuaEndpointIncident" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_incidents" } + type { name: "bigint" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "description_template" + not_null: true + length: -1 + table { schema: "public" name: "opcua_endpoint_incidents" } + type { name: "text" } + original_name: "description_template" + } + } + params { + number: 3 + column { + name: "opcua_attribute_values" + not_null: true + is_array: true + length: -1 + table { schema: "public" name: "opcua_endpoint_incidents" } + type { name: "opcua_attribute_value" } + original_name: "opcua_attribute_values" + array_dims: 1 + } + } + filename: "queries.sql" + insert_into_table { name: "incident_events" } +} +queries { + text: "WITH opcua_node_incidents AS (\n INSERT INTO\n opcua_node_incidents (id, description_template, opcua_attribute_values)\n VALUES ($1, $2, $3)\n ON CONFLICT (id) DO NOTHING\n RETURNING id, description_template, opcua_attribute_values, created_at, updated_at\n),\nmonitor_failed_event AS (\n INSERT INTO\n incident_events (incident_id, type, failing_monitor)\n SELECT\n opcua_node_incidents.id, \'monitor_failed\', incidents.failing_monitor\n FROM\n opcua_node_incidents JOIN incidents ON opcua_node_incidents.id = incidents.id\n)\nINSERT INTO\n incident_events (incident_id, type)\nSELECT\n opcua_node_incidents.id, \'incident_started\'\nFROM\n opcua_node_incidents JOIN incidents ON opcua_node_incidents.id = incidents.id" + name: "createOpcuaNodeIncident" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_incidents" } + type { name: "bigint" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "description_template" + not_null: true + length: -1 + table { schema: "public" name: "opcua_node_incidents" } + type { name: "text" } + original_name: "description_template" + } + } + params { + number: 3 + column { + name: "opcua_attribute_values" + not_null: true + is_array: true + length: -1 + table { schema: "public" name: "opcua_node_incidents" } + type { name: "opcua_attribute_value" } + original_name: "opcua_attribute_values" + array_dims: 1 + } + } + filename: "queries.sql" + insert_into_table { name: "incident_events" } +} +queries { + text: "INSERT INTO\nincidents (organization_id, display_name, description, failing_monitor, status)\nVALUES\n($1, $2, $3, $4, $5)\nON CONFLICT\n(organization_id, failing_monitor)\nWHERE\nincidents.status <> \'resolved\'\nDO UPDATE SET updated_at = NOW () RETURNING id, organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, created_at, updated_at" + name: "createIncidentFromMonitorIfNotExists" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "lead_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "lead_by" + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "acknowledged_by" + } + columns { + name: "unacknowledged_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "unacknowledged_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "incidents" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "display_name" + not_null: true + length: -1 + table { schema: "public" name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + } + params { + number: 3 + column { + name: "description" + length: -1 + table { schema: "public" name: "incidents" } + type { name: "text" } + original_name: "description" + } + } + params { + number: 4 + column { + name: "failing_monitor" + length: -1 + table { schema: "public" name: "incidents" } + type { name: "integer" } + original_name: "failing_monitor" + } + } + params { + number: 5 + column { + name: "status" + not_null: true + length: -1 + table { schema: "public" name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + } + filename: "queries.sql" + insert_into_table { name: "incidents" } +} +queries { + text: "WITH incident_result AS (\n INSERT INTO incidents (organization_id, display_name, description, failing_monitor, status)\n VALUES ($1, $2, $3, $4, \'unacknowledged\')\n ON CONFLICT (organization_id, failing_monitor)\n WHERE incidents.status <> \'resolved\'\n DO UPDATE SET updated_at = NOW()\n RETURNING id, organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, created_at, updated_at\n),\nescalation_policy AS (\n SELECT\n COALESCE(monitors.escalation_policy_id, def_ep.id) as policy_id,\n monitors.threshold_failures as monitor_threshold\n FROM incident_result\n LEFT JOIN monitors ON incident_result.failing_monitor = monitors.id\n LEFT JOIN escalation_policies def_ep ON incident_result.organization_id = def_ep.organization_id\n AND def_ep.is_default = TRUE AND NOT def_ep.is_deleted\n),\nfirst_step AS (\n SELECT escalation_steps.delay_interval\n FROM escalation_policy\n INNER JOIN escalation_steps ON escalation_policy.policy_id = escalation_steps.escalation_policy_id\n WHERE escalation_steps.step_order = 0\n LIMIT 1\n),\nescalation_result AS (\n INSERT INTO incident_escalations (id, escalation_policy_id, threshold, failed_checks, next_escalation_at)\n SELECT\n incident_result.id,\n escalation_policy.policy_id,\n escalation_policy.monitor_threshold, -- use monitor\'s threshold\n 1, -- start with 1 failed check\n CASE\n WHEN escalation_policy.monitor_threshold <= 1 THEN incident_result.created_at + COALESCE(first_step.delay_interval, INTERVAL \'1 minute\')\n ELSE NULL -- Don\'t schedule escalation until threshold is exceeded\n END\n FROM incident_result\n CROSS JOIN escalation_policy\n LEFT JOIN first_step ON true\n ON CONFLICT (id)\n DO UPDATE SET\n failed_checks = incident_escalations.failed_checks + 1,\n next_escalation_at = CASE\n WHEN incident_escalations.failed_checks + 1 >= incident_escalations.threshold\n AND incident_escalations.next_escalation_at IS NULL\n THEN NOW() + INTERVAL \'1 minute\'\n ELSE incident_escalations.next_escalation_at\n END,\n updated_at = NOW()\n RETURNING id, escalation_policy_id, current_step, escalation_started_at, next_escalation_at, is_active, threshold, failed_checks, incident_notification_sent_at, resolved_notification_sent_at, acknowledged_notification_sent_at, created_at, updated_at\n)\nSELECT incident_result.id, incident_result.organization_id, incident_result.display_name, incident_result.description, incident_result.failing_monitor, incident_result.status, incident_result.lead_by, incident_result.acknowledged_by, incident_result.unacknowledged_at, incident_result.created_at, incident_result.updated_at FROM incident_result" + name: "createIncidentWithEscalation" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_result" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "incident_result" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "incident_result" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incident_result" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incident_result" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + not_null: true + length: -1 + table { name: "incident_result" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "lead_by" + length: -1 + table { name: "incident_result" } + type { schema: "pg_catalog" name: "int4" } + original_name: "lead_by" + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incident_result" } + type { schema: "pg_catalog" name: "int4" } + original_name: "acknowledged_by" + } + columns { + name: "unacknowledged_at" + length: -1 + table { name: "incident_result" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "unacknowledged_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incident_result" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incident_result" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "incidents" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "display_name" + not_null: true + length: -1 + table { schema: "public" name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + } + params { + number: 3 + column { + name: "description" + length: -1 + table { schema: "public" name: "incidents" } + type { name: "text" } + original_name: "description" + } + } + params { + number: 4 + column { + name: "failing_monitor" + length: -1 + table { schema: "public" name: "incidents" } + type { name: "integer" } + original_name: "failing_monitor" + } + } + comments: " Creates an incident and sets up escalation policy with threshold handling" + comments: " This creates incidents immediately but only escalates when threshold is exceeded" + comments: " The threshold comes from the monitor\'s threshold_failures configuration" + filename: "queries.sql" +} +queries { + text: "WITH resolved_incidents AS (\n UPDATE\n incidents\n SET\n status = \'resolved\',\n updated_at = NOW()\n WHERE\n incidents.organization_id = $1\n AND incidents.status <> \'resolved\'\n AND incidents.failing_monitor IN ($2)\n RETURNING id, organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, created_at, updated_at\n),\nrecovered_monitor_event AS (\n INSERT INTO\n incident_events (incident_id, type, failing_monitor)\n SELECT\n resolved_incidents.id, \'monitor_recovered\', resolved_incidents.failing_monitor\n FROM\n resolved_incidents\n)\nINSERT INTO\n incident_events (incident_id, type)\nSELECT\n resolved_incidents.id, \'incident_resolved\'\nFROM\n resolved_incidents\nRETURNING id, incident_id, type, failing_monitor, notification_recipients, acknowledged_by, resolved_by, created_at" + name: "resolveIncidentsByFailingMonitors" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_events" } + type { name: "serial8" } + original_name: "id" + } + columns { + name: "incident_id" + not_null: true + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int8" } + original_name: "incident_id" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "incident_events" } + type { name: "event_type" } + original_name: "type" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "notification_recipients" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + original_name: "notification_recipients" + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + original_name: "acknowledged_by" + } + columns { + name: "resolved_by" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + original_name: "resolved_by" + } + columns { + name: "created_at" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "failing_monitors" + length: -1 + is_named_param: true + table { name: "incidents" } + type { name: "integer" } + is_sqlc_slice: true + original_name: "failing_monitor" + } + } + filename: "queries.sql" + insert_into_table { name: "incident_events" } +} +queries { + text: "UPDATE\n incidents\nSET\n status = \'acknowledged\',\n updated_at = NOW()\nWHERE\n incidents.id IN ($1)\n AND incidents.status = \'unacknowledged\'\nRETURNING id, organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, created_at, updated_at" + name: "setIncidentToAcknowledged" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "lead_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "lead_by" + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "acknowledged_by" + } + columns { + name: "unacknowledged_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "unacknowledged_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "incidents_ids" + not_null: true + length: -1 + is_named_param: true + table { name: "incidents" } + type { name: "bigint" } + is_sqlc_slice: true + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE heartbeat_monitors SET last_heartbeat = NOW()\nFROM monitors\nWHERE\n monitors.id = heartbeat_monitors.id\n AND NOT monitors.is_deleted\n AND heartbeat_slug = $1\nRETURNING monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, updated_at, escalation_policy_id, heartbeat_monitors.id, heartbeat_slug, last_heartbeat, expected_interval, heartbeat_monitors.created_at" + name: "tickleHeartbeatMonitor" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + not_null: true + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "heartbeat_slug" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "varchar" } + original_name: "heartbeat_slug" + } + columns { + name: "last_heartbeat" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_heartbeat" + } + columns { + name: "expected_interval" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "interval" } + original_name: "expected_interval" + } + columns { + name: "created_at" + length: -1 + table { name: "heartbeat_monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + params { + number: 1 + column { + name: "heartbeat_slug" + not_null: true + length: -1 + table { name: "heartbeat_monitors" } + type { name: "text" } + original_name: "heartbeat_slug" + } + } + filename: "queries.sql" +} +queries { + text: "DELETE\nFROM opcua_attribute_values\nWHERE created_at + \'24 hours\' < NOW()" + name: "deleteAgedSamples" + cmd: ":exec" + filename: "queries.sql" +} +queries { + text: "SELECT id, team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert, created_at, updated_at FROM severities\nWHERE team_id = $1\nORDER BY name ASC" + name: "getSeverities" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "team_id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + original_name: "team_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "severities" } + type { name: "text" } + original_name: "name" + } + columns { + name: "notify_by_email" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_email" + } + columns { + name: "notify_by_push" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_push" + } + columns { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_critical_alert" + } + columns { + name: "created_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "team_id" + not_null: true + length: -1 + table { name: "severities" } + type { name: "integer" } + original_name: "team_id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert, created_at, updated_at FROM severities\nWHERE id = $1" + name: "getSeverityById" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "team_id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + original_name: "team_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "severities" } + type { name: "text" } + original_name: "name" + } + columns { + name: "notify_by_email" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_email" + } + columns { + name: "notify_by_push" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_push" + } + columns { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_critical_alert" + } + columns { + name: "created_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "severities" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO severities (\n team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert\n) VALUES ($1, $2, $3, $4, $5) RETURNING id, team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert, created_at, updated_at" + name: "insertSeverity" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "team_id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + original_name: "team_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "severities" } + type { name: "text" } + original_name: "name" + } + columns { + name: "notify_by_email" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_email" + } + columns { + name: "notify_by_push" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_push" + } + columns { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_critical_alert" + } + columns { + name: "created_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "team_id" + not_null: true + length: -1 + table { schema: "public" name: "severities" } + type { name: "integer" } + original_name: "team_id" + } + } + params { + number: 2 + column { + name: "name" + not_null: true + length: -1 + table { schema: "public" name: "severities" } + type { name: "text" } + original_name: "name" + } + } + params { + number: 3 + column { + name: "notify_by_email" + not_null: true + length: -1 + table { schema: "public" name: "severities" } + type { name: "boolean" } + original_name: "notify_by_email" + } + } + params { + number: 4 + column { + name: "notify_by_push" + not_null: true + length: -1 + table { schema: "public" name: "severities" } + type { name: "boolean" } + original_name: "notify_by_push" + } + } + params { + number: 5 + column { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { schema: "public" name: "severities" } + type { name: "boolean" } + original_name: "notify_by_critical_alert" + } + } + filename: "queries.sql" + insert_into_table { name: "severities" } +} +queries { + text: "UPDATE severities\nSET\n name = COALESCE($2::TEXT, severities.name),\n notify_by_email = COALESCE($3::BOOLEAN, severities.notify_by_email),\n notify_by_push = COALESCE($4::BOOLEAN, severities.notify_by_push),\n notify_by_critical_alert = COALESCE($5::BOOLEAN, severities.notify_by_critical_alert),\n updated_at = NOW()\nWHERE id = $1\nRETURNING id, team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert, created_at, updated_at" + name: "updateSeverity" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "team_id" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "int4" } + original_name: "team_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "severities" } + type { name: "text" } + original_name: "name" + } + columns { + name: "notify_by_email" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_email" + } + columns { + name: "notify_by_push" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_push" + } + columns { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_critical_alert" + } + columns { + name: "created_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "severities" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "severities" } + type { name: "integer" } + original_name: "id" + } + } + params { + number: 2 column { name: "name" length: -1 type { name: "text" } } + } + params { + number: 3 + column { + name: "notify_by_email" + length: -1 + type { schema: "pg_catalog" name: "bool" } + } + } + params { + number: 4 + column { + name: "notify_by_push" + length: -1 + type { schema: "pg_catalog" name: "bool" } + } + } + params { + number: 5 + column { + name: "notify_by_critical_alert" + length: -1 + type { schema: "pg_catalog" name: "bool" } + } + } + filename: "queries.sql" +} +queries { + text: "DELETE FROM severities\nWHERE id = $1" + name: "deleteSeverity" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "severities" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "\nSELECT id, organization_id, name, description, is_default, is_deleted, created_at, updated_at FROM escalation_policies\nWHERE organization_id = $1 AND NOT is_deleted\nORDER BY name ASC" + name: "getEscalationPolicies" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "name" + } + columns { + name: "description" + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "description" + } + columns { + name: "is_default" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_default" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "integer" } + original_name: "organization_id" + } + } + comments: "------------------------------------------------------------------------" + comments: " Escalation Policy Queries" + comments: "------------------------------------------------------------------------" + filename: "queries.sql" +} +queries { + text: "SELECT id, organization_id, name, description, is_default, is_deleted, created_at, updated_at FROM escalation_policies\nWHERE id = $1 AND NOT is_deleted" + name: "getEscalationPolicyById" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "name" + } + columns { + name: "description" + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "description" + } + columns { + name: "is_default" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_default" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, organization_id, name, description, is_default, is_deleted, created_at, updated_at FROM escalation_policies\nWHERE organization_id = $1 AND is_default = TRUE AND NOT is_deleted" + name: "getDefaultEscalationPolicy" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "name" + } + columns { + name: "description" + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "description" + } + columns { + name: "is_default" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_default" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "integer" } + original_name: "organization_id" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO escalation_policies (\n organization_id, name, description, is_default\n) VALUES ($1, $2, $3, $4) RETURNING id, organization_id, name, description, is_default, is_deleted, created_at, updated_at" + name: "insertEscalationPolicy" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "name" + } + columns { + name: "description" + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "description" + } + columns { + name: "is_default" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_default" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "escalation_policies" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "name" + not_null: true + length: -1 + table { schema: "public" name: "escalation_policies" } + type { name: "text" } + original_name: "name" + } + } + params { + number: 3 + column { + name: "description" + length: -1 + table { schema: "public" name: "escalation_policies" } + type { name: "text" } + original_name: "description" + } + } + params { + number: 4 + column { + name: "is_default" + not_null: true + length: -1 + table { schema: "public" name: "escalation_policies" } + type { name: "boolean" } + original_name: "is_default" + } + } + filename: "queries.sql" + insert_into_table { name: "escalation_policies" } +} +queries { + text: "UPDATE escalation_policies\nSET\n name = COALESCE($2::TEXT, escalation_policies.name),\n description = COALESCE($3::TEXT, escalation_policies.description),\n is_default = COALESCE($4::BOOLEAN, escalation_policies.is_default),\n updated_at = NOW()\nWHERE id = $1 AND NOT is_deleted\nRETURNING id, organization_id, name, description, is_default, is_deleted, created_at, updated_at" + name: "updateEscalationPolicy" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "name" + } + columns { + name: "description" + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "description" + } + columns { + name: "is_default" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_default" + } + columns { + name: "is_deleted" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_policies" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "integer" } + original_name: "id" + } + } + params { + number: 2 column { name: "name" length: -1 type { name: "text" } } + } + params { + number: 3 + column { name: "description" length: -1 type { name: "text" } } + } + params { + number: 4 + column { + name: "is_default" + length: -1 + type { schema: "pg_catalog" name: "bool" } + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE escalation_policies\nSET is_deleted = TRUE, updated_at = NOW()\nWHERE id = $1" + name: "deleteEscalationPolicy" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, escalation_policy_id, step_order, delay_interval, notify_by_email, notify_by_push, notify_by_critical_alert, message_template, created_at, updated_at FROM escalation_steps\nWHERE escalation_policy_id = $1\nORDER BY step_order ASC" + name: "getEscalationSteps" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "step_order" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + original_name: "step_order" + } + columns { + name: "delay_interval" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "interval" } + original_name: "delay_interval" + } + columns { + name: "notify_by_email" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_email" + } + columns { + name: "notify_by_push" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_push" + } + columns { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_critical_alert" + } + columns { + name: "message_template" + length: -1 + table { name: "escalation_steps" } + type { name: "text" } + original_name: "message_template" + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { name: "integer" } + original_name: "escalation_policy_id" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO escalation_steps (\n escalation_policy_id, step_order, delay_interval,\n notify_by_email, notify_by_push, notify_by_critical_alert, message_template\n) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING id, escalation_policy_id, step_order, delay_interval, notify_by_email, notify_by_push, notify_by_critical_alert, message_template, created_at, updated_at" + name: "insertEscalationStep" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "step_order" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + original_name: "step_order" + } + columns { + name: "delay_interval" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "interval" } + original_name: "delay_interval" + } + columns { + name: "notify_by_email" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_email" + } + columns { + name: "notify_by_push" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_push" + } + columns { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_critical_alert" + } + columns { + name: "message_template" + length: -1 + table { name: "escalation_steps" } + type { name: "text" } + original_name: "message_template" + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "escalation_policy_id" + not_null: true + length: -1 + table { schema: "public" name: "escalation_steps" } + type { name: "integer" } + original_name: "escalation_policy_id" + } + } + params { + number: 2 + column { + name: "step_order" + not_null: true + length: -1 + table { schema: "public" name: "escalation_steps" } + type { name: "integer" } + original_name: "step_order" + } + } + params { + number: 3 + column { + name: "delay_interval" + not_null: true + length: -1 + table { schema: "public" name: "escalation_steps" } + type { name: "interval" } + original_name: "delay_interval" + } + } + params { + number: 4 + column { + name: "notify_by_email" + not_null: true + length: -1 + table { schema: "public" name: "escalation_steps" } + type { name: "boolean" } + original_name: "notify_by_email" + } + } + params { + number: 5 + column { + name: "notify_by_push" + not_null: true + length: -1 + table { schema: "public" name: "escalation_steps" } + type { name: "boolean" } + original_name: "notify_by_push" + } + } + params { + number: 6 + column { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { schema: "public" name: "escalation_steps" } + type { name: "boolean" } + original_name: "notify_by_critical_alert" + } + } + params { + number: 7 + column { + name: "message_template" + length: -1 + table { schema: "public" name: "escalation_steps" } + type { name: "text" } + original_name: "message_template" + } + } + filename: "queries.sql" + insert_into_table { name: "escalation_steps" } +} +queries { + text: "UPDATE escalation_steps\nSET\n step_order = COALESCE($2::INTEGER, escalation_steps.step_order),\n delay_interval = COALESCE($3::INTERVAL, escalation_steps.delay_interval),\n notify_by_email = COALESCE($4::BOOLEAN, escalation_steps.notify_by_email),\n notify_by_push = COALESCE($5::BOOLEAN, escalation_steps.notify_by_push),\n notify_by_critical_alert = COALESCE($6::BOOLEAN, escalation_steps.notify_by_critical_alert),\n message_template = COALESCE($7::TEXT, escalation_steps.message_template),\n updated_at = NOW()\nWHERE id = $1\nRETURNING id, escalation_policy_id, step_order, delay_interval, notify_by_email, notify_by_push, notify_by_critical_alert, message_template, created_at, updated_at" + name: "updateEscalationStep" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "step_order" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "int4" } + original_name: "step_order" + } + columns { + name: "delay_interval" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "interval" } + original_name: "delay_interval" + } + columns { + name: "notify_by_email" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_email" + } + columns { + name: "notify_by_push" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_push" + } + columns { + name: "notify_by_critical_alert" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "bool" } + original_name: "notify_by_critical_alert" + } + columns { + name: "message_template" + length: -1 + table { name: "escalation_steps" } + type { name: "text" } + original_name: "message_template" + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "escalation_steps" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { name: "integer" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "step_order" + length: -1 + type { schema: "pg_catalog" name: "int4" } + } + } + params { + number: 3 + column { + name: "delay_interval" + length: -1 + type { schema: "pg_catalog" name: "interval" } + } + } + params { + number: 4 + column { + name: "notify_by_email" + length: -1 + type { schema: "pg_catalog" name: "bool" } + } + } + params { + number: 5 + column { + name: "notify_by_push" + length: -1 + type { schema: "pg_catalog" name: "bool" } + } + } + params { + number: 6 + column { + name: "notify_by_critical_alert" + length: -1 + type { schema: "pg_catalog" name: "bool" } + } + } + params { + number: 7 + column { + name: "message_template" length: -1 type { name: "text" } + } + } + filename: "queries.sql" +} +queries { + text: "DELETE FROM escalation_steps\nWHERE id = $1" + name: "deleteEscalationStep" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "escalation_steps" } + type { name: "integer" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "\nINSERT INTO incident_escalations (\n id, escalation_policy_id, next_escalation_at\n) VALUES ($1, $2, $3) RETURNING id, escalation_policy_id, current_step, escalation_started_at, next_escalation_at, is_active, threshold, failed_checks, incident_notification_sent_at, resolved_notification_sent_at, acknowledged_notification_sent_at, created_at, updated_at" + name: "createIncidentEscalation" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "current_step" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "current_step" + } + columns { + name: "escalation_started_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "escalation_started_at" + } + columns { + name: "next_escalation_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "next_escalation_at" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "threshold" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold" + } + columns { + name: "failed_checks" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failed_checks" + } + columns { + name: "incident_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "incident_notification_sent_at" + } + columns { + name: "resolved_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "resolved_notification_sent_at" + } + columns { + name: "acknowledged_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "acknowledged_notification_sent_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { schema: "public" name: "incident_escalations" } + type { name: "bigint" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "escalation_policy_id" + not_null: true + length: -1 + table { schema: "public" name: "incident_escalations" } + type { name: "integer" } + original_name: "escalation_policy_id" + } + } + params { + number: 3 + column { + name: "next_escalation_at" + length: -1 + table { schema: "public" name: "incident_escalations" } + type { name: "pg_catalog.timestamptz" } + original_name: "next_escalation_at" + } + } + comments: "------------------------------------------------------------------------" + comments: " Incident Escalation Queries" + comments: "------------------------------------------------------------------------" + filename: "queries.sql" + insert_into_table { name: "incident_escalations" } +} +queries { + text: "SELECT id, escalation_policy_id, current_step, escalation_started_at, next_escalation_at, is_active, threshold, failed_checks, incident_notification_sent_at, resolved_notification_sent_at, acknowledged_notification_sent_at, created_at, updated_at FROM incident_escalations\nWHERE id = $1" + name: "getIncidentEscalation" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "current_step" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "current_step" + } + columns { + name: "escalation_started_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "escalation_started_at" + } + columns { + name: "next_escalation_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "next_escalation_at" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "threshold" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold" + } + columns { + name: "failed_checks" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failed_checks" + } + columns { + name: "incident_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "incident_notification_sent_at" + } + columns { + name: "resolved_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "resolved_notification_sent_at" + } + columns { + name: "acknowledged_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "acknowledged_notification_sent_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { name: "bigint" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE incident_escalations\nSET\n current_step = COALESCE($2::INTEGER, incident_escalations.current_step),\n next_escalation_at = COALESCE($3::TIMESTAMP WITH TIME ZONE, incident_escalations.next_escalation_at),\n is_active = COALESCE($4::BOOLEAN, incident_escalations.is_active),\n updated_at = NOW()\nWHERE id = $1\nRETURNING id, escalation_policy_id, current_step, escalation_started_at, next_escalation_at, is_active, threshold, failed_checks, incident_notification_sent_at, resolved_notification_sent_at, acknowledged_notification_sent_at, created_at, updated_at" + name: "updateIncidentEscalation" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "current_step" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "current_step" + } + columns { + name: "escalation_started_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "escalation_started_at" + } + columns { + name: "next_escalation_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "next_escalation_at" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "threshold" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold" + } + columns { + name: "failed_checks" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failed_checks" + } + columns { + name: "incident_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "incident_notification_sent_at" + } + columns { + name: "resolved_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "resolved_notification_sent_at" + } + columns { + name: "acknowledged_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "acknowledged_notification_sent_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { name: "bigint" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "current_step" + length: -1 + type { schema: "pg_catalog" name: "int4" } + } + } + params { + number: 3 + column { + name: "next_escalation_at" + length: -1 + type { schema: "pg_catalog" name: "timestamptz" } + } + } + params { + number: 4 + column { + name: "is_active" + length: -1 + type { schema: "pg_catalog" name: "bool" } + } + } + filename: "queries.sql" +} +queries { + text: "SELECT\n ie.id, ie.escalation_policy_id, ie.current_step, ie.escalation_started_at, ie.next_escalation_at, ie.is_active, ie.threshold, ie.failed_checks, ie.incident_notification_sent_at, ie.resolved_notification_sent_at, ie.acknowledged_notification_sent_at, ie.created_at, ie.updated_at,\n i.id,\n i.organization_id,\n i.display_name,\n i.description,\n i.failing_monitor,\n i.status,\n i.created_at,\n ep.name as escalation_policy_name,\n monitors.id, monitors.organization_id, monitors.name, monitors.type, monitors.healthiness, monitors.monitor_group, monitors.threshold_failures, monitors.is_active, monitors.is_deleted, monitors.last_checked, monitors.created_at, monitors.updated_at, monitors.escalation_policy_id\nFROM incident_escalations ie\nINNER JOIN incidents i ON ie.id = i.id\nINNER JOIN escalation_policies ep ON ie.escalation_policy_id = ep.id\nLEFT JOIN monitors ON monitors.id = i.failing_monitor\nWHERE\n ie.is_active = TRUE\n AND ie.next_escalation_at <= NOW()\n AND i.status NOT IN (\'acknowledged\', \'resolved\')\nORDER BY ie.next_escalation_at ASC\nLIMIT 100" + name: "getIncidentsToEscalate" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "current_step" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "current_step" + } + columns { + name: "escalation_started_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "escalation_started_at" + } + columns { + name: "next_escalation_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "next_escalation_at" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "threshold" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold" + } + columns { + name: "failed_checks" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failed_checks" + } + columns { + name: "incident_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "incident_notification_sent_at" + } + columns { + name: "resolved_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "resolved_notification_sent_at" + } + columns { + name: "acknowledged_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "acknowledged_notification_sent_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "escalation_policy_name" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "name" + } + columns { + name: "id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + filename: "queries.sql" +} +queries { + text: "UPDATE incident_escalations\nSET is_active = FALSE, updated_at = NOW()\nWHERE id = $1" + name: "pauseIncidentEscalation" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { name: "bigint" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE incident_escalations\nSET is_active = TRUE, updated_at = NOW()\nWHERE id = $1" + name: "resumeIncidentEscalation" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { name: "bigint" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO escalation_notifications (\n incident_escalation_id, step_order, notification_channel, delivery_status\n) VALUES ($1, $2, $3, $4) RETURNING id, incident_escalation_id, step_order, notification_channel, sent_at, delivery_status, error_message, created_at" + name: "insertEscalationNotification" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "incident_escalation_id" + not_null: true + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "int8" } + original_name: "incident_escalation_id" + } + columns { + name: "step_order" + not_null: true + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "int4" } + original_name: "step_order" + } + columns { + name: "notification_channel" + not_null: true + length: -1 + table { name: "escalation_notifications" } + type { name: "text" } + original_name: "notification_channel" + } + columns { + name: "sent_at" + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "sent_at" + } + columns { + name: "delivery_status" + length: -1 + table { name: "escalation_notifications" } + type { name: "text" } + original_name: "delivery_status" + } + columns { + name: "error_message" + length: -1 + table { name: "escalation_notifications" } + type { name: "text" } + original_name: "error_message" + } + columns { + name: "created_at" + length: -1 + table { name: "escalation_notifications" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + params { + number: 1 + column { + name: "incident_escalation_id" + not_null: true + length: -1 + table { schema: "public" name: "escalation_notifications" } + type { name: "bigint" } + original_name: "incident_escalation_id" + } + } + params { + number: 2 + column { + name: "step_order" + not_null: true + length: -1 + table { schema: "public" name: "escalation_notifications" } + type { name: "integer" } + original_name: "step_order" + } + } + params { + number: 3 + column { + name: "notification_channel" + not_null: true + length: -1 + table { schema: "public" name: "escalation_notifications" } + type { name: "text" } + original_name: "notification_channel" + } + } + params { + number: 4 + column { + name: "delivery_status" + length: -1 + table { schema: "public" name: "escalation_notifications" } + type { name: "text" } + original_name: "delivery_status" + } + } + filename: "queries.sql" + insert_into_table { name: "escalation_notifications" } +} +queries { + text: "UPDATE escalation_notifications\nSET\n delivery_status = $2,\n error_message = COALESCE($3::TEXT, error_message)\nWHERE id = $1" + name: "updateEscalationNotificationStatus" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "escalation_notifications" } + type { name: "bigint" } + original_name: "id" + } + } + params { + number: 2 + column { + name: "delivery_status" + length: -1 + table { schema: "public" name: "escalation_notifications" } + type { name: "text" } + original_name: "delivery_status" + } + } + params { + number: 3 + column { name: "error_message" length: -1 type { name: "text" } } + } + filename: "queries.sql" +} +queries { + text: "SELECT\n ie.id, ie.escalation_policy_id, ie.current_step, ie.escalation_started_at, ie.next_escalation_at, ie.is_active, ie.threshold, ie.failed_checks, ie.incident_notification_sent_at, ie.resolved_notification_sent_at, ie.acknowledged_notification_sent_at, ie.created_at, ie.updated_at,\n i.id,\n i.organization_id,\n i.display_name,\n i.description,\n i.failing_monitor,\n i.status,\n i.created_at,\n ep.name as escalation_policy_name\nFROM incident_escalations ie\nINNER JOIN incidents i ON ie.id = i.id\nINNER JOIN escalation_policies ep ON ie.escalation_policy_id = ep.id\nWHERE\n i.status = \'resolved\'\n AND ie.incident_notification_sent_at IS NOT NULL\n AND ie.resolved_notification_sent_at IS NULL\nORDER BY i.updated_at ASC\nLIMIT 100" + name: "getResolvedIncidentsForNotification" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "current_step" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "current_step" + } + columns { + name: "escalation_started_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "escalation_started_at" + } + columns { + name: "next_escalation_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "next_escalation_at" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "threshold" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold" + } + columns { + name: "failed_checks" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failed_checks" + } + columns { + name: "incident_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "incident_notification_sent_at" + } + columns { + name: "resolved_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "resolved_notification_sent_at" + } + columns { + name: "acknowledged_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "acknowledged_notification_sent_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "escalation_policy_name" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "name" + } + filename: "queries.sql" +} +queries { + text: "UPDATE incident_escalations\nSET incident_notification_sent_at = NOW(), updated_at = NOW()\nWHERE id = $1" + name: "markIncidentNotificationSent" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { name: "bigint" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "UPDATE incident_escalations\nSET resolved_notification_sent_at = NOW(), updated_at = NOW()\nWHERE id = $1" + name: "markResolvedNotificationSent" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { name: "bigint" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT\n ie.id, ie.escalation_policy_id, ie.current_step, ie.escalation_started_at, ie.next_escalation_at, ie.is_active, ie.threshold, ie.failed_checks, ie.incident_notification_sent_at, ie.resolved_notification_sent_at, ie.acknowledged_notification_sent_at, ie.created_at, ie.updated_at,\n i.id,\n i.organization_id,\n i.display_name,\n i.description,\n i.failing_monitor,\n i.status,\n i.created_at,\n ep.name as escalation_policy_name,\n monitors.id, monitors.organization_id, monitors.name, monitors.type, monitors.healthiness, monitors.monitor_group, monitors.threshold_failures, monitors.is_active, monitors.is_deleted, monitors.last_checked, monitors.created_at, monitors.updated_at, monitors.escalation_policy_id\nFROM incident_escalations ie\nINNER JOIN incidents i ON ie.id = i.id\nINNER JOIN escalation_policies ep ON ie.escalation_policy_id = ep.id\nLEFT JOIN monitors ON monitors.id = i.failing_monitor\nWHERE\n i.status = \'acknowledged\'\n AND ie.incident_notification_sent_at IS NOT NULL\n AND ie.acknowledged_notification_sent_at IS NULL\nORDER BY i.updated_at ASC\nLIMIT 100" + name: "getAcknowledgedIncidentsForNotification" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "escalation_policy_id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + columns { + name: "current_step" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "current_step" + } + columns { + name: "escalation_started_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "escalation_started_at" + } + columns { + name: "next_escalation_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "next_escalation_at" + } + columns { + name: "is_active" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "threshold" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold" + } + columns { + name: "failed_checks" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failed_checks" + } + columns { + name: "incident_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "incident_notification_sent_at" + } + columns { + name: "resolved_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "resolved_notification_sent_at" + } + columns { + name: "acknowledged_notification_sent_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "acknowledged_notification_sent_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incident_escalations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "escalation_policy_name" + not_null: true + length: -1 + table { name: "escalation_policies" } + type { name: "text" } + original_name: "name" + } + columns { + name: "id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + filename: "queries.sql" +} +queries { + text: "UPDATE incident_escalations\nSET acknowledged_notification_sent_at = NOW(), updated_at = NOW()\nWHERE id = $1" + name: "markAcknowledgedNotificationSent" + cmd: ":exec" + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "incident_escalations" } + type { name: "bigint" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT\n incident_events.id, incident_id, incident_events.type, incident_events.failing_monitor, notification_recipients, incident_events.acknowledged_by, resolved_by, incident_events.created_at, incidents.id, incidents.organization_id, display_name, description, incidents.failing_monitor, status, lead_by, incidents.acknowledged_by, unacknowledged_at, incidents.created_at, incidents.updated_at, monitors.id, monitors.organization_id, name, monitors.type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id\nFROM\n incident_events\n JOIN incidents ON incident_events.incident_id = incidents.id\n LEFT JOIN monitors ON monitors.id = incident_events.failing_monitor\nWHERE\n incidents.organization_id = $1\n AND (\n incidents.id = ANY($3::BIGINT [])\n OR incident_events.failing_monitor = ANY($4::INT [])\n )\n ORDER BY incident_events.created_at ASC\n LIMIT $2" + name: "getIncidentEvents" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident_events" } + type { name: "serial8" } + original_name: "id" + } + columns { + name: "incident_id" + not_null: true + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int8" } + original_name: "incident_id" + } + columns { + name: "type" + not_null: true + length: -1 + table { name: "incident_events" } + type { name: "event_type" } + original_name: "type" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "notification_recipients" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + original_name: "notification_recipients" + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + original_name: "acknowledged_by" + } + columns { + name: "resolved_by" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "int4" } + original_name: "resolved_by" + } + columns { + name: "created_at" + length: -1 + table { name: "incident_events" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int8" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "description" + length: -1 + table { name: "incidents" } + type { name: "text" } + original_name: "description" + } + columns { + name: "failing_monitor" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "failing_monitor" + } + columns { + name: "status" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "incident_status" } + original_name: "status" + } + columns { + name: "lead_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "lead_by" + } + columns { + name: "acknowledged_by" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "int4" } + original_name: "acknowledged_by" + } + columns { + name: "unacknowledged_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "unacknowledged_at" + } + columns { + name: "created_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "incidents" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "id" + } + columns { + name: "organization_id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "name" + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "name" + } + columns { + name: "type" + length: -1 + table { name: "monitors" } + type { name: "monitor_type" } + original_name: "type" + } + columns { + name: "healthiness" + length: -1 + table { name: "monitors" } + type { name: "monitor_healthiness" } + original_name: "healthiness" + } + columns { + name: "monitor_group" + length: -1 + table { name: "monitors" } + type { name: "text" } + original_name: "monitor_group" + } + columns { + name: "threshold_failures" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "threshold_failures" + } + columns { + name: "is_active" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_active" + } + columns { + name: "is_deleted" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "last_checked" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "last_checked" + } + columns { + name: "created_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "escalation_policy_id" + length: -1 + table { name: "monitors" } + type { schema: "pg_catalog" name: "int4" } + original_name: "escalation_policy_id" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "incidents" } + type { name: "integer" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "limit" not_null: true length: -1 type { name: "bigint" } + } + } + params { + number: 3 + column { + name: "incident_ids" + not_null: true + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int8" } + array_dims: 1 + } + } + params { + number: 4 + column { + name: "monitor_ids" + not_null: true + is_array: true + length: -1 + type { schema: "pg_catalog" name: "int4" } + array_dims: 1 + } + } + comments: " LEFT JOIN logins AS acknowledged_by ON acknowledged_by.id = incident_events.acknowledged_by" + comments: " LEFT JOIN logins AS resolved_by ON resolved_by.id = incident_events.resolved_by" + filename: "queries.sql" +} +queries { + text: "SELECT\n endpoint_monitor_id,\n opcua_node_id,\n attribute_id,\n value_type,\n value_integral,\n value_float,\n value_bool,\n value_string,\n value_status_code,\n value,\n created_at\nFROM opcua_attribute_values\nWHERE\n endpoint_monitor_id = $1\n AND opcua_node_id = $2::OPCUA_NODE_ID\n AND attribute_id = $3::OPCUA_ATTRIBUTE_ID\n AND created_at >= $4\n AND created_at <= $5\nORDER BY created_at DESC" + name: "getOpcuaAttributeValuesForTimeRange" + cmd: ":many" + columns { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "int4" } + original_name: "endpoint_monitor_id" + } + columns { + name: "opcua_node_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_node_id" } + original_name: "opcua_node_id" + } + columns { + name: "attribute_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_attribute_id" } + original_name: "attribute_id" + } + columns { + name: "value_type" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_type" } + original_name: "value_type" + } + columns { + name: "value_integral" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "int8" } + original_name: "value_integral" + } + columns { + name: "value_float" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "float8" } + original_name: "value_float" + } + columns { + name: "value_bool" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "bool" } + original_name: "value_bool" + } + columns { + name: "value_string" + length: -1 + table { name: "opcua_attribute_values" } + type { name: "text" } + original_name: "value_string" + } + columns { + name: "value_status_code" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "int4" } + original_name: "value_status_code" + } + columns { + name: "value" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "opcua_value" } + original_name: "value" + } + columns { + name: "created_at" + length: -1 + table { name: "opcua_attribute_values" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + params { + number: 1 + column { + name: "endpoint_monitor_id" + not_null: true + length: -1 + table { name: "opcua_attribute_values" } + type { name: "integer" } + original_name: "endpoint_monitor_id" + } + } + params { + number: 2 + column { + name: "opcua_node_id" + not_null: true + length: -1 + type { name: "opcua_node_id" } + } + } + params { + number: 3 + column { + name: "attribute_id" + not_null: true + length: -1 + type { name: "opcua_attribute_id" } + } + } + params { + number: 4 + column { + name: "start_time" + length: -1 + is_named_param: true + table { name: "opcua_attribute_values" } + type { name: "pg_catalog.timestamptz" } + original_name: "created_at" + } + } + params { + number: 5 + column { + name: "end_time" + length: -1 + is_named_param: true + table { name: "opcua_attribute_values" } + type { name: "pg_catalog.timestamptz" } + original_name: "created_at" + } + } + filename: "queries.sql" +} +sqlc_version: "v1.29.0" +plugin_options: "{\"cabal_default_extensions\":[\"NoFieldSelectors\"],\"cabal_package_name\":\"pulse-db\",\"haskell_module_prefix\":\"Pulse.Database\",\"overrides\":[{\"db_type\":\"x509_certificate\",\"haskell_type\":[{\"type\":\"Maybe (Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString)\"},{\"module\":\"Data.ByteString\",\"package\":\"bytestring\"},{\"module\":\"Database.PostgreSQL.Simple\",\"package\":\"postgresql-simple\"}],\"nullable\":true},{\"db_type\":\"private_key\",\"haskell_type\":[{\"type\":\"Maybe (Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString)\"},{\"module\":\"Data.ByteString\",\"package\":\"bytestring\"},{\"module\":\"Database.PostgreSQL.Simple\",\"package\":\"postgresql-simple\"}],\"nullable\":true},{\"db_type\":\"x509_certificate\",\"haskell_type\":[{\"type\":\"Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString\"},{\"module\":\"Data.ByteString\",\"package\":\"bytestring\"},{\"module\":\"Database.PostgreSQL.Simple\",\"package\":\"postgresql-simple\"}],\"nullable\":false},{\"db_type\":\"private_key\",\"haskell_type\":[{\"type\":\"Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString\"},{\"module\":\"Data.ByteString\",\"package\":\"bytestring\"},{\"module\":\"Database.PostgreSQL.Simple\",\"package\":\"postgresql-simple\"}],\"nullable\":false},{\"db_type\":\"check_expr\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.CheckExpr\"},\"nullable\":false},{\"db_type\":\"opcua_type\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaDataValueType\"},\"nullable\":false},{\"db_type\":\"opcua_attribute_value\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaAttributeValue\"},\"nullable\":true},{\"db_type\":\"opcua_attribute_value\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaAttributeValue\"},\"nullable\":false},{\"db_type\":\"opcua_value\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaDataValue\"},\"nullable\":false},{\"db_type\":\"opcua_value\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaDataValue\"},\"nullable\":true},{\"db_type\":\"opcua_attribute_id\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaAttributeId\"},\"nullable\":false},{\"db_type\":\"opcua_attribute_id\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Maybe Pulse.Database.DBTypes.OpcuaAttributeId\"},\"nullable\":true},{\"db_type\":\"opcua_node_id\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.OpcuaNodeId\"},\"nullable\":false},{\"db_type\":\"opcua_node_id\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Maybe Pulse.Database.DBTypes.OpcuaNodeId\"},\"nullable\":true},{\"db_type\":\"pg_catalog.timestamptz\",\"haskell_type\":{\"module\":\"Data.Time\",\"package\":\"time\",\"type\":\"Maybe Data.Time.UTCTime\"},\"nullable\":true},{\"db_type\":\"pg_catalog.timestamptz\",\"haskell_type\":{\"module\":\"Data.Time\",\"nullable\":false,\"package\":\"time\",\"type\":\"Data.Time.UTCTime\"}},{\"db_type\":\"pg_catalog.interval\",\"haskell_type\":{\"module\":\"Data.Time.LocalTime\",\"package\":\"time\",\"type\":\"Data.Time.LocalTime.CalendarDiffTime\"}},{\"db_type\":\"interval\",\"haskell_type\":{\"module\":\"Data.Time.LocalTime\",\"package\":\"time\",\"type\":\"Data.Time.LocalTime.CalendarDiffTime\"}},{\"db_type\":\"pg_catalog.interval\",\"haskell_type\":{\"module\":\"Data.Time.LocalTime\",\"package\":\"time\",\"type\":\"Maybe Data.Time.LocalTime.CalendarDiffTime\"},\"nullable\":true},{\"db_type\":\"timezone\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Maybe Pulse.Database.DBTypes.Timezone\"},\"nullable\":true},{\"db_type\":\"timezone\",\"haskell_type\":{\"module\":\"Pulse.Database.DBTypes\",\"package\":\"pulse-db-types\",\"type\":\"Pulse.Database.DBTypes.Timezone\"}}]}" diff --git a/test/golden/out/Pulse/Database.hs b/test/golden/out/Pulse/Database.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database.hs @@ -0,0 +1,92 @@ +module Pulse.Database + ( module Pulse.Database.Internal, + module Pulse.Database.Types, + module Queries + ) +where + +import Pulse.Database.Internal +import Pulse.Database.Types +import Pulse.Database.GetLoginById as Queries +import Pulse.Database.GetLoginByEmail as Queries +import Pulse.Database.InsertLogin as Queries +import Pulse.Database.GetLoginOrganizations as Queries +import Pulse.Database.GetLoginOrganization as Queries +import Pulse.Database.InsertOrganizationLogin as Queries +import Pulse.Database.GetOrganizations as Queries +import Pulse.Database.GetTeams as Queries +import Pulse.Database.GetLoginTeams as Queries +import Pulse.Database.GetTeamById as Queries +import Pulse.Database.GetTeamByInvitationCode as Queries +import Pulse.Database.GetTeamMembers as Queries +import Pulse.Database.InsertTeamMember as Queries +import Pulse.Database.GetTeamByName as Queries +import Pulse.Database.InsertTeam as Queries +import Pulse.Database.InsertDefaultTeamIfNotExists as Queries +import Pulse.Database.GetIncidents as Queries +import Pulse.Database.GetHeartbeatMonitors as Queries +import Pulse.Database.GetExpiredHeartbeatMonitors as Queries +import Pulse.Database.GetRecoveredHeartbearMonitors as Queries +import Pulse.Database.GetMonitors as Queries +import Pulse.Database.GetOpcuaEndpointMonitors as Queries +import Pulse.Database.GetOpcuaNodeMonitors as Queries +import Pulse.Database.GetOpcuaEndpointMonitorsToCheck as Queries +import Pulse.Database.InsertNewMonitor as Queries +import Pulse.Database.UpdateMonitor as Queries +import Pulse.Database.PauseMonitor as Queries +import Pulse.Database.UnpauseMonitor as Queries +import Pulse.Database.GetOpcuaEndpointCredentials as Queries +import Pulse.Database.InsertOpcuaEndpointCredentials as Queries +import Pulse.Database.GetOpcuaEndpointCertificates as Queries +import Pulse.Database.InsertOpcuaEndpointCertificate as Queries +import Pulse.Database.InsertNewOpcuaEndpointMonitor as Queries +import Pulse.Database.UpdateNewOpcuaEndpointMonitor as Queries +import Pulse.Database.InsertOpcuaNodeMonitor as Queries +import Pulse.Database.UpdateOpcuaNodeMonitor as Queries +import Pulse.Database.GetOpcuaEndpointMonitorsToSample as Queries +import Pulse.Database.GetOpcuaNodeMonitorsToSample as Queries +import Pulse.Database.GetOpcuaNodeMonitorsToCheck as Queries +import Pulse.Database.InsertOpcuaAttributeValue as Queries +import Pulse.Database.GetLatestSampledOpcuaAttributeValues as Queries +import Pulse.Database.GetOpcuaAttributeAggregates as Queries +import Pulse.Database.DeleteMonitor as Queries +import Pulse.Database.FlopMonitorHealthiness as Queries +import Pulse.Database.FlipMonitorHealthiness as Queries +import Pulse.Database.CreateOpcuaEndpointIncident as Queries +import Pulse.Database.CreateOpcuaNodeIncident as Queries +import Pulse.Database.CreateIncidentFromMonitorIfNotExists as Queries +import Pulse.Database.CreateIncidentWithEscalation as Queries +import Pulse.Database.ResolveIncidentsByFailingMonitors as Queries +import Pulse.Database.SetIncidentToAcknowledged as Queries +import Pulse.Database.TickleHeartbeatMonitor as Queries +import Pulse.Database.DeleteAgedSamples as Queries +import Pulse.Database.GetSeverities as Queries +import Pulse.Database.GetSeverityById as Queries +import Pulse.Database.InsertSeverity as Queries +import Pulse.Database.UpdateSeverity as Queries +import Pulse.Database.DeleteSeverity as Queries +import Pulse.Database.GetEscalationPolicies as Queries +import Pulse.Database.GetEscalationPolicyById as Queries +import Pulse.Database.GetDefaultEscalationPolicy as Queries +import Pulse.Database.InsertEscalationPolicy as Queries +import Pulse.Database.UpdateEscalationPolicy as Queries +import Pulse.Database.DeleteEscalationPolicy as Queries +import Pulse.Database.GetEscalationSteps as Queries +import Pulse.Database.InsertEscalationStep as Queries +import Pulse.Database.UpdateEscalationStep as Queries +import Pulse.Database.DeleteEscalationStep as Queries +import Pulse.Database.CreateIncidentEscalation as Queries +import Pulse.Database.GetIncidentEscalation as Queries +import Pulse.Database.UpdateIncidentEscalation as Queries +import Pulse.Database.GetIncidentsToEscalate as Queries +import Pulse.Database.PauseIncidentEscalation as Queries +import Pulse.Database.ResumeIncidentEscalation as Queries +import Pulse.Database.InsertEscalationNotification as Queries +import Pulse.Database.UpdateEscalationNotificationStatus as Queries +import Pulse.Database.GetResolvedIncidentsForNotification as Queries +import Pulse.Database.MarkIncidentNotificationSent as Queries +import Pulse.Database.MarkResolvedNotificationSent as Queries +import Pulse.Database.GetAcknowledgedIncidentsForNotification as Queries +import Pulse.Database.MarkAcknowledgedNotificationSent as Queries +import Pulse.Database.GetIncidentEvents as Queries +import Pulse.Database.GetOpcuaAttributeValuesForTimeRange as Queries diff --git a/test/golden/out/Pulse/Database/CreateIncidentEscalation.hs b/test/golden/out/Pulse/Database/CreateIncidentEscalation.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/CreateIncidentEscalation.hs @@ -0,0 +1,76 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.CreateIncidentEscalation where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Time +import qualified GHC.Types +import qualified Data.Foldable + +query_createIncidentEscalation :: Query "createIncidentEscalation" ":one" +query_createIncidentEscalation = Query "\nINSERT INTO incident_escalations (\n id, escalation_policy_id, next_escalation_at\n) VALUES (?, ?, ?) RETURNING id, escalation_policy_id, current_step, escalation_started_at, next_escalation_at, is_active, threshold, failed_checks, incident_notification_sent_at, resolved_notification_sent_at, acknowledged_notification_sent_at, created_at, updated_at" + +data instance Params "createIncidentEscalation" = Params_createIncidentEscalation + { + incident_escalations_id :: Data.Int.Int64, + incident_escalations_escalation_policy_id :: Data.Int.Int32, + incident_escalations_next_escalation_at :: (Maybe Data.Time.UTCTime) + } + +data instance Result "createIncidentEscalation" = Result_createIncidentEscalation + { + incident_escalations_id :: !(Data.Int.Int64), + incident_escalations_escalation_policy_id :: !(Data.Int.Int32), + incident_escalations_current_step :: !(Data.Int.Int32), + incident_escalations_escalation_started_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_next_escalation_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_is_active :: !(GHC.Types.Bool), + incident_escalations_threshold :: !(Data.Int.Int32), + incident_escalations_failed_checks :: !(Data.Int.Int32), + incident_escalations_incident_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_resolved_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_acknowledged_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_created_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "createIncidentEscalation") where + toRow Params_createIncidentEscalation{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incident_escalations_id, + + Database.PostgreSQL.Simple.ToField.toField incident_escalations_escalation_policy_id, + + Database.PostgreSQL.Simple.ToField.toField incident_escalations_next_escalation_at + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "createIncidentEscalation") where + fromRow = + pure Result_createIncidentEscalation + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/CreateIncidentFromMonitorIfNotExists.hs b/test/golden/out/Pulse/Database/CreateIncidentFromMonitorIfNotExists.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/CreateIncidentFromMonitorIfNotExists.hs @@ -0,0 +1,80 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.CreateIncidentFromMonitorIfNotExists where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified Pulse.Database.Types +import qualified Data.Time +import qualified Data.Foldable + +query_createIncidentFromMonitorIfNotExists :: Query "createIncidentFromMonitorIfNotExists" ":one" +query_createIncidentFromMonitorIfNotExists = Query "INSERT INTO\nincidents (organization_id, display_name, description, failing_monitor, status)\nVALUES\n(?, ?, ?, ?, ?)\nON CONFLICT\n(organization_id, failing_monitor)\nWHERE\nincidents.status <> 'resolved'\nDO UPDATE SET updated_at = NOW () RETURNING id, organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, created_at, updated_at" + +data instance Params "createIncidentFromMonitorIfNotExists" = Params_createIncidentFromMonitorIfNotExists + { + incidents_organization_id :: Data.Int.Int32, + incidents_display_name :: Data.Text.Text, + incidents_description :: GHC.Base.Maybe Data.Text.Text, + incidents_failing_monitor :: GHC.Base.Maybe Data.Int.Int32, + incidents_status :: (Pulse.Database.Types.Enum "incident_status") + } + +data instance Result "createIncidentFromMonitorIfNotExists" = Result_createIncidentFromMonitorIfNotExists + { + incidents_id :: !(Data.Int.Int64), + incidents_organization_id :: !(Data.Int.Int32), + incidents_display_name :: !(Data.Text.Text), + incidents_description :: !(GHC.Base.Maybe Data.Text.Text), + incidents_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_status :: !((Pulse.Database.Types.Enum "incident_status")), + incidents_lead_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_acknowledged_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_unacknowledged_at :: !((Maybe Data.Time.UTCTime)), + incidents_created_at :: !((Maybe Data.Time.UTCTime)), + incidents_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "createIncidentFromMonitorIfNotExists") where + toRow Params_createIncidentFromMonitorIfNotExists{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incidents_organization_id, + + Database.PostgreSQL.Simple.ToField.toField incidents_display_name, + + Database.PostgreSQL.Simple.ToField.toField incidents_description, + + Database.PostgreSQL.Simple.ToField.toField incidents_failing_monitor, + + Database.PostgreSQL.Simple.ToField.toField incidents_status + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "createIncidentFromMonitorIfNotExists") where + fromRow = + pure Result_createIncidentFromMonitorIfNotExists + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/CreateIncidentWithEscalation.hs b/test/golden/out/Pulse/Database/CreateIncidentWithEscalation.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/CreateIncidentWithEscalation.hs @@ -0,0 +1,77 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.CreateIncidentWithEscalation where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified Pulse.Database.Types +import qualified Data.Time +import qualified Data.Foldable + +query_createIncidentWithEscalation :: Query "createIncidentWithEscalation" ":one" +query_createIncidentWithEscalation = Query "WITH incident_result AS (\n INSERT INTO incidents (organization_id, display_name, description, failing_monitor, status)\n VALUES (?, ?, ?, ?, 'unacknowledged')\n ON CONFLICT (organization_id, failing_monitor)\n WHERE incidents.status <> 'resolved'\n DO UPDATE SET updated_at = NOW()\n RETURNING id, organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, created_at, updated_at\n),\nescalation_policy AS (\n SELECT\n COALESCE(monitors.escalation_policy_id, def_ep.id) as policy_id,\n monitors.threshold_failures as monitor_threshold\n FROM incident_result\n LEFT JOIN monitors ON incident_result.failing_monitor = monitors.id\n LEFT JOIN escalation_policies def_ep ON incident_result.organization_id = def_ep.organization_id\n AND def_ep.is_default = TRUE AND NOT def_ep.is_deleted\n),\nfirst_step AS (\n SELECT escalation_steps.delay_interval\n FROM escalation_policy\n INNER JOIN escalation_steps ON escalation_policy.policy_id = escalation_steps.escalation_policy_id\n WHERE escalation_steps.step_order = 0\n LIMIT 1\n),\nescalation_result AS (\n INSERT INTO incident_escalations (id, escalation_policy_id, threshold, failed_checks, next_escalation_at)\n SELECT\n incident_result.id,\n escalation_policy.policy_id,\n escalation_policy.monitor_threshold, -- use monitor's threshold\n 1, -- start with 1 failed check\n CASE\n WHEN escalation_policy.monitor_threshold <= 1 THEN incident_result.created_at + COALESCE(first_step.delay_interval, INTERVAL '1 minute')\n ELSE NULL -- Don't schedule escalation until threshold is exceeded\n END\n FROM incident_result\n CROSS JOIN escalation_policy\n LEFT JOIN first_step ON true\n ON CONFLICT (id)\n DO UPDATE SET\n failed_checks = incident_escalations.failed_checks + 1,\n next_escalation_at = CASE\n WHEN incident_escalations.failed_checks + 1 >= incident_escalations.threshold\n AND incident_escalations.next_escalation_at IS NULL\n THEN NOW() + INTERVAL '1 minute'\n ELSE incident_escalations.next_escalation_at\n END,\n updated_at = NOW()\n RETURNING id, escalation_policy_id, current_step, escalation_started_at, next_escalation_at, is_active, threshold, failed_checks, incident_notification_sent_at, resolved_notification_sent_at, acknowledged_notification_sent_at, created_at, updated_at\n)\nSELECT incident_result.id, incident_result.organization_id, incident_result.display_name, incident_result.description, incident_result.failing_monitor, incident_result.status, incident_result.lead_by, incident_result.acknowledged_by, incident_result.unacknowledged_at, incident_result.created_at, incident_result.updated_at FROM incident_result" + +data instance Params "createIncidentWithEscalation" = Params_createIncidentWithEscalation + { + incidents_organization_id :: Data.Int.Int32, + incidents_display_name :: Data.Text.Text, + incidents_description :: GHC.Base.Maybe Data.Text.Text, + incidents_failing_monitor :: GHC.Base.Maybe Data.Int.Int32 + } + +data instance Result "createIncidentWithEscalation" = Result_createIncidentWithEscalation + { + incident_result_id :: !(Data.Int.Int64), + incident_result_organization_id :: !(Data.Int.Int32), + incident_result_display_name :: !(Data.Text.Text), + incident_result_description :: !(GHC.Base.Maybe Data.Text.Text), + incident_result_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incident_result_status :: !((Pulse.Database.Types.Enum "incident_status")), + incident_result_lead_by :: !(GHC.Base.Maybe Data.Int.Int32), + incident_result_acknowledged_by :: !(GHC.Base.Maybe Data.Int.Int32), + incident_result_unacknowledged_at :: !((Maybe Data.Time.UTCTime)), + incident_result_created_at :: !((Maybe Data.Time.UTCTime)), + incident_result_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "createIncidentWithEscalation") where + toRow Params_createIncidentWithEscalation{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incidents_organization_id, + + Database.PostgreSQL.Simple.ToField.toField incidents_display_name, + + Database.PostgreSQL.Simple.ToField.toField incidents_description, + + Database.PostgreSQL.Simple.ToField.toField incidents_failing_monitor + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "createIncidentWithEscalation") where + fromRow = + pure Result_createIncidentWithEscalation + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/CreateOpcuaEndpointIncident.hs b/test/golden/out/Pulse/Database/CreateOpcuaEndpointIncident.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/CreateOpcuaEndpointIncident.hs @@ -0,0 +1,51 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.CreateOpcuaEndpointIncident where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.DBTypes +import qualified Data.Vector +import qualified Data.Foldable + +query_createOpcuaEndpointIncident :: Query "createOpcuaEndpointIncident" ":exec" +query_createOpcuaEndpointIncident = Query "WITH opcua_endpoint_incidents AS (\n INSERT INTO\n opcua_endpoint_incidents (id, description_template, opcua_attribute_values)\n VALUES (?, ?, ?)\n ON CONFLICT (id) DO NOTHING\n RETURNING id, description_template, opcua_attribute_values, created_at, updated_at\n),\nmonitor_failed_event AS (\n INSERT INTO\n incident_events (incident_id, type, failing_monitor)\n SELECT\n opcua_endpoint_incidents.id, 'monitor_failed', incidents.failing_monitor\n FROM\n opcua_endpoint_incidents JOIN incidents ON opcua_endpoint_incidents.id = incidents.id\n)\nINSERT INTO\n incident_events (incident_id, type)\nSELECT\n opcua_endpoint_incidents.id, 'incident_started'\nFROM\n opcua_endpoint_incidents JOIN incidents ON opcua_endpoint_incidents.id = incidents.id" + +data instance Params "createOpcuaEndpointIncident" = Params_createOpcuaEndpointIncident + { + opcua_endpoint_incidents_id :: Data.Int.Int64, + opcua_endpoint_incidents_description_template :: Data.Text.Text, + opcua_endpoint_incidents_opcua_attribute_values :: Data.Vector.Vector Pulse.Database.DBTypes.OpcuaAttributeValue + } + +data instance Result "createOpcuaEndpointIncident" = Result_createOpcuaEndpointIncident + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "createOpcuaEndpointIncident") where + toRow Params_createOpcuaEndpointIncident{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_incidents_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_incidents_description_template, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_incidents_opcua_attribute_values + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "createOpcuaEndpointIncident") where + fromRow = + pure Result_createOpcuaEndpointIncident + + diff --git a/test/golden/out/Pulse/Database/CreateOpcuaNodeIncident.hs b/test/golden/out/Pulse/Database/CreateOpcuaNodeIncident.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/CreateOpcuaNodeIncident.hs @@ -0,0 +1,51 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.CreateOpcuaNodeIncident where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.DBTypes +import qualified Data.Vector +import qualified Data.Foldable + +query_createOpcuaNodeIncident :: Query "createOpcuaNodeIncident" ":exec" +query_createOpcuaNodeIncident = Query "WITH opcua_node_incidents AS (\n INSERT INTO\n opcua_node_incidents (id, description_template, opcua_attribute_values)\n VALUES (?, ?, ?)\n ON CONFLICT (id) DO NOTHING\n RETURNING id, description_template, opcua_attribute_values, created_at, updated_at\n),\nmonitor_failed_event AS (\n INSERT INTO\n incident_events (incident_id, type, failing_monitor)\n SELECT\n opcua_node_incidents.id, 'monitor_failed', incidents.failing_monitor\n FROM\n opcua_node_incidents JOIN incidents ON opcua_node_incidents.id = incidents.id\n)\nINSERT INTO\n incident_events (incident_id, type)\nSELECT\n opcua_node_incidents.id, 'incident_started'\nFROM\n opcua_node_incidents JOIN incidents ON opcua_node_incidents.id = incidents.id" + +data instance Params "createOpcuaNodeIncident" = Params_createOpcuaNodeIncident + { + opcua_node_incidents_id :: Data.Int.Int64, + opcua_node_incidents_description_template :: Data.Text.Text, + opcua_node_incidents_opcua_attribute_values :: Data.Vector.Vector Pulse.Database.DBTypes.OpcuaAttributeValue + } + +data instance Result "createOpcuaNodeIncident" = Result_createOpcuaNodeIncident + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "createOpcuaNodeIncident") where + toRow Params_createOpcuaNodeIncident{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_node_incidents_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_incidents_description_template, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_incidents_opcua_attribute_values + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "createOpcuaNodeIncident") where + fromRow = + pure Result_createOpcuaNodeIncident + + diff --git a/test/golden/out/Pulse/Database/DeleteAgedSamples.hs b/test/golden/out/Pulse/Database/DeleteAgedSamples.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/DeleteAgedSamples.hs @@ -0,0 +1,38 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.DeleteAgedSamples where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Foldable + +query_deleteAgedSamples :: Query "deleteAgedSamples" ":exec" +query_deleteAgedSamples = Query "DELETE\nFROM opcua_attribute_values\nWHERE created_at + '24 hours' < NOW()" + +data instance Params "deleteAgedSamples" = Params_deleteAgedSamples + { + } + +data instance Result "deleteAgedSamples" = Result_deleteAgedSamples + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "deleteAgedSamples") where + toRow Params_deleteAgedSamples{} = + [ ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "deleteAgedSamples") where + fromRow = + pure Result_deleteAgedSamples + + diff --git a/test/golden/out/Pulse/Database/DeleteEscalationPolicy.hs b/test/golden/out/Pulse/Database/DeleteEscalationPolicy.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/DeleteEscalationPolicy.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.DeleteEscalationPolicy where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_deleteEscalationPolicy :: Query "deleteEscalationPolicy" ":exec" +query_deleteEscalationPolicy = Query "UPDATE escalation_policies\nSET is_deleted = TRUE, updated_at = NOW()\nWHERE id = ?" + +data instance Params "deleteEscalationPolicy" = Params_deleteEscalationPolicy + { + escalation_policies_id :: Data.Int.Int32 + } + +data instance Result "deleteEscalationPolicy" = Result_deleteEscalationPolicy + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "deleteEscalationPolicy") where + toRow Params_deleteEscalationPolicy{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_policies_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "deleteEscalationPolicy") where + fromRow = + pure Result_deleteEscalationPolicy + + diff --git a/test/golden/out/Pulse/Database/DeleteEscalationStep.hs b/test/golden/out/Pulse/Database/DeleteEscalationStep.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/DeleteEscalationStep.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.DeleteEscalationStep where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_deleteEscalationStep :: Query "deleteEscalationStep" ":exec" +query_deleteEscalationStep = Query "DELETE FROM escalation_steps\nWHERE id = ?" + +data instance Params "deleteEscalationStep" = Params_deleteEscalationStep + { + escalation_steps_id :: Data.Int.Int32 + } + +data instance Result "deleteEscalationStep" = Result_deleteEscalationStep + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "deleteEscalationStep") where + toRow Params_deleteEscalationStep{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_steps_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "deleteEscalationStep") where + fromRow = + pure Result_deleteEscalationStep + + diff --git a/test/golden/out/Pulse/Database/DeleteMonitor.hs b/test/golden/out/Pulse/Database/DeleteMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/DeleteMonitor.hs @@ -0,0 +1,45 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.DeleteMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_deleteMonitor :: Query "deleteMonitor" ":exec" +query_deleteMonitor = Query "UPDATE\n monitors\nSET\n is_deleted = true\nWHERE\n organization_id = ?\n AND id = ?" + +data instance Params "deleteMonitor" = Params_deleteMonitor + { + monitors_organization_id :: Data.Int.Int32, + monitors_id :: Data.Int.Int32 + } + +data instance Result "deleteMonitor" = Result_deleteMonitor + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "deleteMonitor") where + toRow Params_deleteMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id, + + Database.PostgreSQL.Simple.ToField.toField monitors_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "deleteMonitor") where + fromRow = + pure Result_deleteMonitor + + diff --git a/test/golden/out/Pulse/Database/DeleteSeverity.hs b/test/golden/out/Pulse/Database/DeleteSeverity.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/DeleteSeverity.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.DeleteSeverity where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_deleteSeverity :: Query "deleteSeverity" ":exec" +query_deleteSeverity = Query "DELETE FROM severities\nWHERE id = ?" + +data instance Params "deleteSeverity" = Params_deleteSeverity + { + severities_id :: Data.Int.Int32 + } + +data instance Result "deleteSeverity" = Result_deleteSeverity + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "deleteSeverity") where + toRow Params_deleteSeverity{..} = + [ + Database.PostgreSQL.Simple.ToField.toField severities_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "deleteSeverity") where + fromRow = + pure Result_deleteSeverity + + diff --git a/test/golden/out/Pulse/Database/FlipMonitorHealthiness.hs b/test/golden/out/Pulse/Database/FlipMonitorHealthiness.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/FlipMonitorHealthiness.hs @@ -0,0 +1,72 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.FlipMonitorHealthiness where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_flipMonitorHealthiness :: Query "flipMonitorHealthiness" ":many" +query_flipMonitorHealthiness = Query "UPDATE\n monitors\nSET\n healthiness = 'unhealthy'::monitor_healthiness,\n last_checked = NOW(),\n updated_at = NOW()\nWHERE\n monitors.id IN ?\nRETURNING id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id" + +data instance Params "flipMonitorHealthiness" = Params_flipMonitorHealthiness + { + monitors_monitor_ids :: [Data.Int.Int32] + } + +data instance Result "flipMonitorHealthiness" = Result_flipMonitorHealthiness + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "flipMonitorHealthiness") where + toRow Params_flipMonitorHealthiness{..} = + [ + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList monitors_monitor_ids)) + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "flipMonitorHealthiness") where + fromRow = + pure Result_flipMonitorHealthiness + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/FlopMonitorHealthiness.hs b/test/golden/out/Pulse/Database/FlopMonitorHealthiness.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/FlopMonitorHealthiness.hs @@ -0,0 +1,72 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.FlopMonitorHealthiness where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_flopMonitorHealthiness :: Query "flopMonitorHealthiness" ":many" +query_flopMonitorHealthiness = Query "UPDATE\n monitors\nSET\n healthiness = 'healthy',\n last_checked = NOW(),\n updated_at = NOW()\nWHERE\n monitors.id IN ?\nRETURNING id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id" + +data instance Params "flopMonitorHealthiness" = Params_flopMonitorHealthiness + { + monitors_monitor_ids :: [Data.Int.Int32] + } + +data instance Result "flopMonitorHealthiness" = Result_flopMonitorHealthiness + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "flopMonitorHealthiness") where + toRow Params_flopMonitorHealthiness{..} = + [ + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList monitors_monitor_ids)) + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "flopMonitorHealthiness") where + fromRow = + pure Result_flopMonitorHealthiness + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetAcknowledgedIncidentsForNotification.hs b/test/golden/out/Pulse/Database/GetAcknowledgedIncidentsForNotification.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetAcknowledgedIncidentsForNotification.hs @@ -0,0 +1,112 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetAcknowledgedIncidentsForNotification where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Time +import qualified GHC.Types +import qualified Data.Text +import qualified GHC.Base +import qualified Pulse.Database.Types +import qualified Data.Foldable + +query_getAcknowledgedIncidentsForNotification :: Query "getAcknowledgedIncidentsForNotification" ":many" +query_getAcknowledgedIncidentsForNotification = Query "SELECT\n ie.id, ie.escalation_policy_id, ie.current_step, ie.escalation_started_at, ie.next_escalation_at, ie.is_active, ie.threshold, ie.failed_checks, ie.incident_notification_sent_at, ie.resolved_notification_sent_at, ie.acknowledged_notification_sent_at, ie.created_at, ie.updated_at,\n i.id,\n i.organization_id,\n i.display_name,\n i.description,\n i.failing_monitor,\n i.status,\n i.created_at,\n ep.name as escalation_policy_name,\n monitors.id, monitors.organization_id, monitors.name, monitors.type, monitors.healthiness, monitors.monitor_group, monitors.threshold_failures, monitors.is_active, monitors.is_deleted, monitors.last_checked, monitors.created_at, monitors.updated_at, monitors.escalation_policy_id\nFROM incident_escalations ie\nINNER JOIN incidents i ON ie.id = i.id\nINNER JOIN escalation_policies ep ON ie.escalation_policy_id = ep.id\nLEFT JOIN monitors ON monitors.id = i.failing_monitor\nWHERE\n i.status = 'acknowledged'\n AND ie.incident_notification_sent_at IS NOT NULL\n AND ie.acknowledged_notification_sent_at IS NULL\nORDER BY i.updated_at ASC\nLIMIT 100" + +data instance Params "getAcknowledgedIncidentsForNotification" = Params_getAcknowledgedIncidentsForNotification + { + } + +data instance Result "getAcknowledgedIncidentsForNotification" = Result_getAcknowledgedIncidentsForNotification + { + incident_escalations_id :: !(Data.Int.Int64), + incident_escalations_escalation_policy_id :: !(Data.Int.Int32), + incident_escalations_current_step :: !(Data.Int.Int32), + incident_escalations_escalation_started_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_next_escalation_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_is_active :: !(GHC.Types.Bool), + incident_escalations_threshold :: !(Data.Int.Int32), + incident_escalations_failed_checks :: !(Data.Int.Int32), + incident_escalations_incident_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_resolved_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_acknowledged_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_created_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_updated_at :: !((Maybe Data.Time.UTCTime)), + incidents_id :: !(Data.Int.Int64), + incidents_organization_id :: !(Data.Int.Int32), + incidents_display_name :: !(Data.Text.Text), + incidents_description :: !(GHC.Base.Maybe Data.Text.Text), + incidents_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_status :: !((Pulse.Database.Types.Enum "incident_status")), + incidents_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_policies_escalation_policy_name :: !(Data.Text.Text), + monitors_id :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_organization_id :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_name :: !(GHC.Base.Maybe Data.Text.Text), + monitors_type :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "monitor_type"))), + monitors_healthiness :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "monitor_healthiness"))), + monitors_monitor_group :: !(GHC.Base.Maybe Data.Text.Text), + monitors_threshold_failures :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_is_active :: !(GHC.Base.Maybe GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(GHC.Base.Maybe Data.Int.Int32) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getAcknowledgedIncidentsForNotification") where + toRow Params_getAcknowledgedIncidentsForNotification{} = + [ ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getAcknowledgedIncidentsForNotification") where + fromRow = + pure Result_getAcknowledgedIncidentsForNotification + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetDefaultEscalationPolicy.hs b/test/golden/out/Pulse/Database/GetDefaultEscalationPolicy.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetDefaultEscalationPolicy.hs @@ -0,0 +1,62 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetDefaultEscalationPolicy where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getDefaultEscalationPolicy :: Query "getDefaultEscalationPolicy" ":one" +query_getDefaultEscalationPolicy = Query "SELECT id, organization_id, name, description, is_default, is_deleted, created_at, updated_at FROM escalation_policies\nWHERE organization_id = ? AND is_default = TRUE AND NOT is_deleted" + +data instance Params "getDefaultEscalationPolicy" = Params_getDefaultEscalationPolicy + { + escalation_policies_organization_id :: Data.Int.Int32 + } + +data instance Result "getDefaultEscalationPolicy" = Result_getDefaultEscalationPolicy + { + escalation_policies_id :: !(Data.Int.Int32), + escalation_policies_organization_id :: !(Data.Int.Int32), + escalation_policies_name :: !(Data.Text.Text), + escalation_policies_description :: !(GHC.Base.Maybe Data.Text.Text), + escalation_policies_is_default :: !(GHC.Types.Bool), + escalation_policies_is_deleted :: !(GHC.Types.Bool), + escalation_policies_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_policies_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getDefaultEscalationPolicy") where + toRow Params_getDefaultEscalationPolicy{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_policies_organization_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getDefaultEscalationPolicy") where + fromRow = + pure Result_getDefaultEscalationPolicy + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetEscalationPolicies.hs b/test/golden/out/Pulse/Database/GetEscalationPolicies.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetEscalationPolicies.hs @@ -0,0 +1,62 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetEscalationPolicies where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getEscalationPolicies :: Query "getEscalationPolicies" ":many" +query_getEscalationPolicies = Query "\nSELECT id, organization_id, name, description, is_default, is_deleted, created_at, updated_at FROM escalation_policies\nWHERE organization_id = ? AND NOT is_deleted\nORDER BY name ASC" + +data instance Params "getEscalationPolicies" = Params_getEscalationPolicies + { + escalation_policies_organization_id :: Data.Int.Int32 + } + +data instance Result "getEscalationPolicies" = Result_getEscalationPolicies + { + escalation_policies_id :: !(Data.Int.Int32), + escalation_policies_organization_id :: !(Data.Int.Int32), + escalation_policies_name :: !(Data.Text.Text), + escalation_policies_description :: !(GHC.Base.Maybe Data.Text.Text), + escalation_policies_is_default :: !(GHC.Types.Bool), + escalation_policies_is_deleted :: !(GHC.Types.Bool), + escalation_policies_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_policies_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getEscalationPolicies") where + toRow Params_getEscalationPolicies{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_policies_organization_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getEscalationPolicies") where + fromRow = + pure Result_getEscalationPolicies + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetEscalationPolicyById.hs b/test/golden/out/Pulse/Database/GetEscalationPolicyById.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetEscalationPolicyById.hs @@ -0,0 +1,62 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetEscalationPolicyById where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getEscalationPolicyById :: Query "getEscalationPolicyById" ":one" +query_getEscalationPolicyById = Query "SELECT id, organization_id, name, description, is_default, is_deleted, created_at, updated_at FROM escalation_policies\nWHERE id = ? AND NOT is_deleted" + +data instance Params "getEscalationPolicyById" = Params_getEscalationPolicyById + { + escalation_policies_id :: Data.Int.Int32 + } + +data instance Result "getEscalationPolicyById" = Result_getEscalationPolicyById + { + escalation_policies_id :: !(Data.Int.Int32), + escalation_policies_organization_id :: !(Data.Int.Int32), + escalation_policies_name :: !(Data.Text.Text), + escalation_policies_description :: !(GHC.Base.Maybe Data.Text.Text), + escalation_policies_is_default :: !(GHC.Types.Bool), + escalation_policies_is_deleted :: !(GHC.Types.Bool), + escalation_policies_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_policies_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getEscalationPolicyById") where + toRow Params_getEscalationPolicyById{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_policies_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getEscalationPolicyById") where + fromRow = + pure Result_getEscalationPolicyById + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetEscalationSteps.hs b/test/golden/out/Pulse/Database/GetEscalationSteps.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetEscalationSteps.hs @@ -0,0 +1,67 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetEscalationSteps where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Time.LocalTime +import qualified GHC.Types +import qualified Data.Text +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_getEscalationSteps :: Query "getEscalationSteps" ":many" +query_getEscalationSteps = Query "SELECT id, escalation_policy_id, step_order, delay_interval, notify_by_email, notify_by_push, notify_by_critical_alert, message_template, created_at, updated_at FROM escalation_steps\nWHERE escalation_policy_id = ?\nORDER BY step_order ASC" + +data instance Params "getEscalationSteps" = Params_getEscalationSteps + { + escalation_steps_escalation_policy_id :: Data.Int.Int32 + } + +data instance Result "getEscalationSteps" = Result_getEscalationSteps + { + escalation_steps_id :: !(Data.Int.Int32), + escalation_steps_escalation_policy_id :: !(Data.Int.Int32), + escalation_steps_step_order :: !(Data.Int.Int32), + escalation_steps_delay_interval :: !(Data.Time.LocalTime.CalendarDiffTime), + escalation_steps_notify_by_email :: !(GHC.Types.Bool), + escalation_steps_notify_by_push :: !(GHC.Types.Bool), + escalation_steps_notify_by_critical_alert :: !(GHC.Types.Bool), + escalation_steps_message_template :: !(GHC.Base.Maybe Data.Text.Text), + escalation_steps_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_steps_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getEscalationSteps") where + toRow Params_getEscalationSteps{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_steps_escalation_policy_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getEscalationSteps") where + fromRow = + pure Result_getEscalationSteps + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetExpiredHeartbeatMonitors.hs b/test/golden/out/Pulse/Database/GetExpiredHeartbeatMonitors.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetExpiredHeartbeatMonitors.hs @@ -0,0 +1,83 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetExpiredHeartbeatMonitors where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Time.LocalTime +import qualified Data.Foldable + +query_getExpiredHeartbeatMonitors :: Query "getExpiredHeartbeatMonitors" ":many" +query_getExpiredHeartbeatMonitors = Query "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, updated_at, escalation_policy_id, heartbeat_monitors.id, heartbeat_slug, last_heartbeat, expected_interval, heartbeat_monitors.created_at\nFROM\n monitors\nINNER JOIN\n heartbeat_monitors ON monitors.id = heartbeat_monitors.id\nWHERE\n monitors.organization_id = ?\n AND monitors.type = 'heartbeat'\n AND monitors.is_active\n AND NOT monitors.is_deleted\n AND heartbeat_monitors.last_heartbeat + heartbeat_monitors.expected_interval < NOW()" + +data instance Params "getExpiredHeartbeatMonitors" = Params_getExpiredHeartbeatMonitors + { + monitors_organization_id :: Data.Int.Int32 + } + +data instance Result "getExpiredHeartbeatMonitors" = Result_getExpiredHeartbeatMonitors + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + heartbeat_monitors_id :: !(Data.Int.Int32), + heartbeat_monitors_heartbeat_slug :: !(Data.Text.Text), + heartbeat_monitors_last_heartbeat :: !((Maybe Data.Time.UTCTime)), + heartbeat_monitors_expected_interval :: !(Data.Time.LocalTime.CalendarDiffTime), + heartbeat_monitors_created_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getExpiredHeartbeatMonitors") where + toRow Params_getExpiredHeartbeatMonitors{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getExpiredHeartbeatMonitors") where + fromRow = + pure Result_getExpiredHeartbeatMonitors + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetHeartbeatMonitors.hs b/test/golden/out/Pulse/Database/GetHeartbeatMonitors.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetHeartbeatMonitors.hs @@ -0,0 +1,89 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetHeartbeatMonitors where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Time.LocalTime +import qualified Data.Foldable + +query_getHeartbeatMonitors :: Query "getHeartbeatMonitors" ":many" +query_getHeartbeatMonitors = Query "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, updated_at, escalation_policy_id, heartbeat_monitors.id, heartbeat_slug, last_heartbeat, expected_interval, heartbeat_monitors.created_at\nFROM monitors\nINNER JOIN heartbeat_monitors ON monitors.id = heartbeat_monitors.id\nWHERE\n monitors.organization_id = ?\n AND monitors.type = 'heartbeat'\n AND NOT monitors.is_deleted\n AND (\n ?::TEXT IS null\n OR monitor_group = ?::TEXT\n )" + +data instance Params "getHeartbeatMonitors" = Params_getHeartbeatMonitors + { + monitors_organization_id :: Data.Int.Int32, + monitor_group :: GHC.Base.Maybe Data.Text.Text + } + +data instance Result "getHeartbeatMonitors" = Result_getHeartbeatMonitors + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + heartbeat_monitors_id :: !(Data.Int.Int32), + heartbeat_monitors_heartbeat_slug :: !(Data.Text.Text), + heartbeat_monitors_last_heartbeat :: !((Maybe Data.Time.UTCTime)), + heartbeat_monitors_expected_interval :: !(Data.Time.LocalTime.CalendarDiffTime), + heartbeat_monitors_created_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getHeartbeatMonitors") where + toRow Params_getHeartbeatMonitors{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id, + + Database.PostgreSQL.Simple.ToField.toField monitor_group, + + Database.PostgreSQL.Simple.ToField.toField monitor_group + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getHeartbeatMonitors") where + fromRow = + pure Result_getHeartbeatMonitors + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetIncidentEscalation.hs b/test/golden/out/Pulse/Database/GetIncidentEscalation.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetIncidentEscalation.hs @@ -0,0 +1,70 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetIncidentEscalation where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Time +import qualified GHC.Types +import qualified Data.Foldable + +query_getIncidentEscalation :: Query "getIncidentEscalation" ":one" +query_getIncidentEscalation = Query "SELECT id, escalation_policy_id, current_step, escalation_started_at, next_escalation_at, is_active, threshold, failed_checks, incident_notification_sent_at, resolved_notification_sent_at, acknowledged_notification_sent_at, created_at, updated_at FROM incident_escalations\nWHERE id = ?" + +data instance Params "getIncidentEscalation" = Params_getIncidentEscalation + { + incident_escalations_id :: Data.Int.Int64 + } + +data instance Result "getIncidentEscalation" = Result_getIncidentEscalation + { + incident_escalations_id :: !(Data.Int.Int64), + incident_escalations_escalation_policy_id :: !(Data.Int.Int32), + incident_escalations_current_step :: !(Data.Int.Int32), + incident_escalations_escalation_started_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_next_escalation_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_is_active :: !(GHC.Types.Bool), + incident_escalations_threshold :: !(Data.Int.Int32), + incident_escalations_failed_checks :: !(Data.Int.Int32), + incident_escalations_incident_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_resolved_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_acknowledged_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_created_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getIncidentEscalation") where + toRow Params_getIncidentEscalation{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incident_escalations_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getIncidentEscalation") where + fromRow = + pure Result_getIncidentEscalation + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetIncidentEvents.hs b/test/golden/out/Pulse/Database/GetIncidentEvents.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetIncidentEvents.hs @@ -0,0 +1,121 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetIncidentEvents where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Vector +import qualified Pulse.Database.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Text +import qualified GHC.Types +import qualified Data.Foldable + +query_getIncidentEvents :: Query "getIncidentEvents" ":many" +query_getIncidentEvents = Query "SELECT\n incident_events.id, incident_id, incident_events.type, incident_events.failing_monitor, notification_recipients, incident_events.acknowledged_by, resolved_by, incident_events.created_at, incidents.id, incidents.organization_id, display_name, description, incidents.failing_monitor, status, lead_by, incidents.acknowledged_by, unacknowledged_at, incidents.created_at, incidents.updated_at, monitors.id, monitors.organization_id, name, monitors.type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id\nFROM\n incident_events\n JOIN incidents ON incident_events.incident_id = incidents.id\n LEFT JOIN monitors ON monitors.id = incident_events.failing_monitor\nWHERE\n incidents.organization_id = ?\n AND (\n incidents.id = ANY(?::BIGINT [])\n OR incident_events.failing_monitor = ANY(?::INT [])\n )\n ORDER BY incident_events.created_at ASC\n LIMIT ?" + +data instance Params "getIncidentEvents" = Params_getIncidentEvents + { + incidents_organization_id :: Data.Int.Int32, + limit :: Data.Int.Int64, + incident_ids :: Data.Vector.Vector Data.Int.Int64, + monitor_ids :: Data.Vector.Vector Data.Int.Int32 + } + +data instance Result "getIncidentEvents" = Result_getIncidentEvents + { + incident_events_id :: !(Data.Int.Int64), + incident_events_incident_id :: !(Data.Int.Int64), + incident_events_type :: !((Pulse.Database.Types.Enum "event_type")), + incident_events_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incident_events_notification_recipients :: !(GHC.Base.Maybe Data.Int.Int32), + incident_events_acknowledged_by :: !(GHC.Base.Maybe Data.Int.Int32), + incident_events_resolved_by :: !(GHC.Base.Maybe Data.Int.Int32), + incident_events_created_at :: !((Maybe Data.Time.UTCTime)), + incidents_id :: !(Data.Int.Int64), + incidents_organization_id :: !(Data.Int.Int32), + incidents_display_name :: !(Data.Text.Text), + incidents_description :: !(GHC.Base.Maybe Data.Text.Text), + incidents_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_status :: !((Pulse.Database.Types.Enum "incident_status")), + incidents_lead_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_acknowledged_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_unacknowledged_at :: !((Maybe Data.Time.UTCTime)), + incidents_created_at :: !((Maybe Data.Time.UTCTime)), + incidents_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_id :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_organization_id :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_name :: !(GHC.Base.Maybe Data.Text.Text), + monitors_type :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "monitor_type"))), + monitors_healthiness :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "monitor_healthiness"))), + monitors_monitor_group :: !(GHC.Base.Maybe Data.Text.Text), + monitors_threshold_failures :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_is_active :: !(GHC.Base.Maybe GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(GHC.Base.Maybe Data.Int.Int32) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getIncidentEvents") where + toRow Params_getIncidentEvents{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incidents_organization_id, + + Database.PostgreSQL.Simple.ToField.toField incident_ids, + + Database.PostgreSQL.Simple.ToField.toField monitor_ids, + + Database.PostgreSQL.Simple.ToField.toField limit + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getIncidentEvents") where + fromRow = + pure Result_getIncidentEvents + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetIncidents.hs b/test/golden/out/Pulse/Database/GetIncidents.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetIncidents.hs @@ -0,0 +1,125 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetIncidents where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified GHC.Base +import qualified Data.Vector +import qualified Pulse.Database.Types +import qualified Data.Text +import qualified Data.Time +import qualified GHC.Types +import qualified Pulse.Database.DBTypes +import qualified Data.Foldable + +query_getIncidents :: Query "getIncidents" ":many" +query_getIncidents = Query "SELECT\n incidents.id, incidents.organization_id, incidents.display_name, incidents.description, incidents.failing_monitor, incidents.status, incidents.lead_by, incidents.acknowledged_by, incidents.unacknowledged_at, incidents.created_at, incidents.updated_at,\n monitors.id, monitors.organization_id, monitors.name, monitors.type, monitors.healthiness, monitors.monitor_group, monitors.threshold_failures, monitors.is_active, monitors.is_deleted, monitors.last_checked, monitors.created_at, monitors.updated_at, monitors.escalation_policy_id,\n opcua_endpoint_incidents.id, opcua_endpoint_incidents.description_template, opcua_endpoint_incidents.opcua_attribute_values, opcua_endpoint_incidents.created_at, opcua_endpoint_incidents.updated_at,\n opcua_node_incidents.id, opcua_node_incidents.description_template, opcua_node_incidents.opcua_attribute_values, opcua_node_incidents.created_at, opcua_node_incidents.updated_at\nFROM incidents\nLEFT JOIN monitors ON incidents.failing_monitor = monitors.id\nLEFT JOIN\n opcua_endpoint_incidents\n ON\n monitors.type = 'opcua_endpoint'\n AND incidents.id = opcua_endpoint_incidents.id\nLEFT JOIN\n opcua_node_incidents\n ON\n monitors.type = 'opcua_node'\n AND incidents.id = opcua_node_incidents.id\nWHERE\n incidents.organization_id = ?\n AND (\n ?::BIGINT [] IS null\n OR incidents.id = ANY(?::BIGINT [])\n )\n AND status IN ?\nORDER BY\n CASE incidents.status\n WHEN 'created' THEN 1\n WHEN 'unacknowledged' THEN 2\n WHEN 'acknowledged' THEN 3\n WHEN 'resolved' THEN 4\n END ASC,\n incidents.created_at DESC" + +data instance Params "getIncidents" = Params_getIncidents + { + incidents_organization_id :: Data.Int.Int32, + incident_ids :: GHC.Base.Maybe (Data.Vector.Vector Data.Int.Int64), + incidents_status :: [(Pulse.Database.Types.Enum "incident_status")] + } + +data instance Result "getIncidents" = Result_getIncidents + { + incidents_id :: !(Data.Int.Int64), + incidents_organization_id :: !(Data.Int.Int32), + incidents_display_name :: !(Data.Text.Text), + incidents_description :: !(GHC.Base.Maybe Data.Text.Text), + incidents_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_status :: !((Pulse.Database.Types.Enum "incident_status")), + incidents_lead_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_acknowledged_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_unacknowledged_at :: !((Maybe Data.Time.UTCTime)), + incidents_created_at :: !((Maybe Data.Time.UTCTime)), + incidents_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_id :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_organization_id :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_name :: !(GHC.Base.Maybe Data.Text.Text), + monitors_type :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "monitor_type"))), + monitors_healthiness :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "monitor_healthiness"))), + monitors_monitor_group :: !(GHC.Base.Maybe Data.Text.Text), + monitors_threshold_failures :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_is_active :: !(GHC.Base.Maybe GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_incidents_id :: !(GHC.Base.Maybe Data.Int.Int64), + opcua_endpoint_incidents_description_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_incidents_opcua_attribute_values :: !(GHC.Base.Maybe (Data.Vector.Vector Pulse.Database.DBTypes.OpcuaAttributeValue)), + opcua_endpoint_incidents_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_incidents_updated_at :: !((Maybe Data.Time.UTCTime)), + opcua_node_incidents_id :: !(GHC.Base.Maybe Data.Int.Int64), + opcua_node_incidents_description_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_node_incidents_opcua_attribute_values :: !(GHC.Base.Maybe (Data.Vector.Vector Pulse.Database.DBTypes.OpcuaAttributeValue)), + opcua_node_incidents_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_node_incidents_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getIncidents") where + toRow Params_getIncidents{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incidents_organization_id, + + Database.PostgreSQL.Simple.ToField.toField incident_ids, + + Database.PostgreSQL.Simple.ToField.toField incident_ids, + + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList incidents_status)) + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getIncidents") where + fromRow = + pure Result_getIncidents + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetIncidentsToEscalate.hs b/test/golden/out/Pulse/Database/GetIncidentsToEscalate.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetIncidentsToEscalate.hs @@ -0,0 +1,112 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetIncidentsToEscalate where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Time +import qualified GHC.Types +import qualified Data.Text +import qualified GHC.Base +import qualified Pulse.Database.Types +import qualified Data.Foldable + +query_getIncidentsToEscalate :: Query "getIncidentsToEscalate" ":many" +query_getIncidentsToEscalate = Query "SELECT\n ie.id, ie.escalation_policy_id, ie.current_step, ie.escalation_started_at, ie.next_escalation_at, ie.is_active, ie.threshold, ie.failed_checks, ie.incident_notification_sent_at, ie.resolved_notification_sent_at, ie.acknowledged_notification_sent_at, ie.created_at, ie.updated_at,\n i.id,\n i.organization_id,\n i.display_name,\n i.description,\n i.failing_monitor,\n i.status,\n i.created_at,\n ep.name as escalation_policy_name,\n monitors.id, monitors.organization_id, monitors.name, monitors.type, monitors.healthiness, monitors.monitor_group, monitors.threshold_failures, monitors.is_active, monitors.is_deleted, monitors.last_checked, monitors.created_at, monitors.updated_at, monitors.escalation_policy_id\nFROM incident_escalations ie\nINNER JOIN incidents i ON ie.id = i.id\nINNER JOIN escalation_policies ep ON ie.escalation_policy_id = ep.id\nLEFT JOIN monitors ON monitors.id = i.failing_monitor\nWHERE\n ie.is_active = TRUE\n AND ie.next_escalation_at <= NOW()\n AND i.status NOT IN ('acknowledged', 'resolved')\nORDER BY ie.next_escalation_at ASC\nLIMIT 100" + +data instance Params "getIncidentsToEscalate" = Params_getIncidentsToEscalate + { + } + +data instance Result "getIncidentsToEscalate" = Result_getIncidentsToEscalate + { + incident_escalations_id :: !(Data.Int.Int64), + incident_escalations_escalation_policy_id :: !(Data.Int.Int32), + incident_escalations_current_step :: !(Data.Int.Int32), + incident_escalations_escalation_started_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_next_escalation_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_is_active :: !(GHC.Types.Bool), + incident_escalations_threshold :: !(Data.Int.Int32), + incident_escalations_failed_checks :: !(Data.Int.Int32), + incident_escalations_incident_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_resolved_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_acknowledged_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_created_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_updated_at :: !((Maybe Data.Time.UTCTime)), + incidents_id :: !(Data.Int.Int64), + incidents_organization_id :: !(Data.Int.Int32), + incidents_display_name :: !(Data.Text.Text), + incidents_description :: !(GHC.Base.Maybe Data.Text.Text), + incidents_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_status :: !((Pulse.Database.Types.Enum "incident_status")), + incidents_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_policies_escalation_policy_name :: !(Data.Text.Text), + monitors_id :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_organization_id :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_name :: !(GHC.Base.Maybe Data.Text.Text), + monitors_type :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "monitor_type"))), + monitors_healthiness :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "monitor_healthiness"))), + monitors_monitor_group :: !(GHC.Base.Maybe Data.Text.Text), + monitors_threshold_failures :: !(GHC.Base.Maybe Data.Int.Int32), + monitors_is_active :: !(GHC.Base.Maybe GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(GHC.Base.Maybe Data.Int.Int32) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getIncidentsToEscalate") where + toRow Params_getIncidentsToEscalate{} = + [ ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getIncidentsToEscalate") where + fromRow = + pure Result_getIncidentsToEscalate + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetLatestSampledOpcuaAttributeValues.hs b/test/golden/out/Pulse/Database/GetLatestSampledOpcuaAttributeValues.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetLatestSampledOpcuaAttributeValues.hs @@ -0,0 +1,66 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetLatestSampledOpcuaAttributeValues where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Vector +import qualified Pulse.Database.DBTypes +import qualified Data.Time +import qualified Data.Time.LocalTime +import qualified Data.Foldable + +query_getLatestSampledOpcuaAttributeValues :: Query "getLatestSampledOpcuaAttributeValues" ":many" +query_getLatestSampledOpcuaAttributeValues = Query "SELECT DISTINCT ON (endpoint_monitor_id, attribute_id, opcua_node_id)\n endpoint_monitor_id,\n attribute_id,\n opcua_node_id,\n value_type,\n value,\n created_at,\n (NOW() - created_at)::INTERVAL AS age\nFROM\n opcua_attribute_values\nWHERE\n endpoint_monitor_id = ANY(?::INTEGER [])\n AND opcua_node_id = ANY(?::OPCUA_NODE_ID [])\n AND attribute_id = ANY(?::OPCUA_ATTRIBUTE_ID [])\nORDER BY\n endpoint_monitor_id ASC,\n attribute_id ASC,\n opcua_node_id ASC,\n created_at DESC" + +data instance Params "getLatestSampledOpcuaAttributeValues" = Params_getLatestSampledOpcuaAttributeValues + { + endpoint_monitor_ids :: Data.Vector.Vector Data.Int.Int32, + node_ids :: Data.Vector.Vector Pulse.Database.DBTypes.OpcuaNodeId, + attribute_ids :: Data.Vector.Vector Pulse.Database.DBTypes.OpcuaAttributeId + } + +data instance Result "getLatestSampledOpcuaAttributeValues" = Result_getLatestSampledOpcuaAttributeValues + { + opcua_attribute_values_endpoint_monitor_id :: !(Data.Int.Int32), + opcua_attribute_values_attribute_id :: !(Pulse.Database.DBTypes.OpcuaAttributeId), + opcua_attribute_values_opcua_node_id :: !(Pulse.Database.DBTypes.OpcuaNodeId), + opcua_attribute_values_value_type :: !(Pulse.Database.DBTypes.OpcuaDataValueType), + opcua_attribute_values_value :: !(Pulse.Database.DBTypes.OpcuaDataValue), + opcua_attribute_values_created_at :: !((Maybe Data.Time.UTCTime)), + age :: !(Data.Time.LocalTime.CalendarDiffTime) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getLatestSampledOpcuaAttributeValues") where + toRow Params_getLatestSampledOpcuaAttributeValues{..} = + [ + Database.PostgreSQL.Simple.ToField.toField endpoint_monitor_ids, + + Database.PostgreSQL.Simple.ToField.toField node_ids, + + Database.PostgreSQL.Simple.ToField.toField attribute_ids + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getLatestSampledOpcuaAttributeValues") where + fromRow = + pure Result_getLatestSampledOpcuaAttributeValues + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetLoginByEmail.hs b/test/golden/out/Pulse/Database/GetLoginByEmail.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetLoginByEmail.hs @@ -0,0 +1,63 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetLoginByEmail where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Text +import qualified Data.Int +import qualified GHC.Base +import qualified GHC.Types +import qualified Pulse.Database.DBTypes +import qualified Data.Time +import qualified Data.Foldable + +query_getLoginByEmail :: Query "getLoginByEmail" ":one" +query_getLoginByEmail = Query "SELECT id, display_name, login_email, password_bcrypt, is_deleted, timezone, created_at, updated_at FROM logins\nWHERE login_email = ? AND NOT is_deleted" + +data instance Params "getLoginByEmail" = Params_getLoginByEmail + { + logins_login_email :: Data.Text.Text + } + +data instance Result "getLoginByEmail" = Result_getLoginByEmail + { + logins_id :: !(Data.Int.Int32), + logins_display_name :: !(GHC.Base.Maybe Data.Text.Text), + logins_login_email :: !(Data.Text.Text), + logins_password_bcrypt :: !(Data.Text.Text), + logins_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + logins_timezone :: !(Pulse.Database.DBTypes.Timezone), + logins_created_at :: !((Maybe Data.Time.UTCTime)), + logins_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getLoginByEmail") where + toRow Params_getLoginByEmail{..} = + [ + Database.PostgreSQL.Simple.ToField.toField logins_login_email + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getLoginByEmail") where + fromRow = + pure Result_getLoginByEmail + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetLoginById.hs b/test/golden/out/Pulse/Database/GetLoginById.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetLoginById.hs @@ -0,0 +1,63 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetLoginById where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Pulse.Database.DBTypes +import qualified Data.Time +import qualified Data.Foldable + +query_getLoginById :: Query "getLoginById" ":one" +query_getLoginById = Query "SELECT id, display_name, login_email, password_bcrypt, is_deleted, timezone, created_at, updated_at FROM logins\nWHERE id = ? AND NOT is_deleted" + +data instance Params "getLoginById" = Params_getLoginById + { + logins_id :: Data.Int.Int32 + } + +data instance Result "getLoginById" = Result_getLoginById + { + logins_id :: !(Data.Int.Int32), + logins_display_name :: !(GHC.Base.Maybe Data.Text.Text), + logins_login_email :: !(Data.Text.Text), + logins_password_bcrypt :: !(Data.Text.Text), + logins_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + logins_timezone :: !(Pulse.Database.DBTypes.Timezone), + logins_created_at :: !((Maybe Data.Time.UTCTime)), + logins_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getLoginById") where + toRow Params_getLoginById{..} = + [ + Database.PostgreSQL.Simple.ToField.toField logins_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getLoginById") where + fromRow = + pure Result_getLoginById + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetLoginOrganization.hs b/test/golden/out/Pulse/Database/GetLoginOrganization.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetLoginOrganization.hs @@ -0,0 +1,79 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetLoginOrganization where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Pulse.Database.DBTypes +import qualified Data.Time +import qualified Pulse.Database.Types +import qualified Data.Foldable + +query_getLoginOrganization :: Query "getLoginOrganization" ":one" +query_getLoginOrganization = Query "SELECT\n logins.id, logins.display_name, logins.login_email, logins.password_bcrypt, logins.is_deleted, logins.timezone, logins.created_at, logins.updated_at,\n organizations.id, organizations.display_name, organizations.timezone, organizations.created_at, organizations.updated_at,\n organization_logins.role\nFROM logins\nINNER JOIN organization_logins ON logins.id = organization_logins.login_id\nINNER JOIN\n organizations\n ON organization_logins.organization_id = organizations.id\nWHERE\n logins.id = ? AND organizations.id = ? AND NOT logins.is_deleted" + +data instance Params "getLoginOrganization" = Params_getLoginOrganization + { + logins_id :: Data.Int.Int32, + organizations_id :: Data.Int.Int32 + } + +data instance Result "getLoginOrganization" = Result_getLoginOrganization + { + logins_id :: !(Data.Int.Int32), + logins_display_name :: !(GHC.Base.Maybe Data.Text.Text), + logins_login_email :: !(Data.Text.Text), + logins_password_bcrypt :: !(Data.Text.Text), + logins_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + logins_timezone :: !(Pulse.Database.DBTypes.Timezone), + logins_created_at :: !((Maybe Data.Time.UTCTime)), + logins_updated_at :: !((Maybe Data.Time.UTCTime)), + organizations_id :: !(Data.Int.Int32), + organizations_display_name :: !(Data.Text.Text), + organizations_timezone :: !(Pulse.Database.DBTypes.Timezone), + organizations_created_at :: !((Maybe Data.Time.UTCTime)), + organizations_updated_at :: !((Maybe Data.Time.UTCTime)), + organization_logins_role :: !((Pulse.Database.Types.Enum "organization_role")) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getLoginOrganization") where + toRow Params_getLoginOrganization{..} = + [ + Database.PostgreSQL.Simple.ToField.toField logins_id, + + Database.PostgreSQL.Simple.ToField.toField organizations_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getLoginOrganization") where + fromRow = + pure Result_getLoginOrganization + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetLoginOrganizations.hs b/test/golden/out/Pulse/Database/GetLoginOrganizations.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetLoginOrganizations.hs @@ -0,0 +1,76 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetLoginOrganizations where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Pulse.Database.DBTypes +import qualified Data.Time +import qualified Pulse.Database.Types +import qualified Data.Foldable + +query_getLoginOrganizations :: Query "getLoginOrganizations" ":many" +query_getLoginOrganizations = Query "SELECT\n logins.id, logins.display_name, logins.login_email, logins.password_bcrypt, logins.is_deleted, logins.timezone, logins.created_at, logins.updated_at,\n organizations.id, organizations.display_name, organizations.timezone, organizations.created_at, organizations.updated_at,\n organization_logins.role\nFROM logins\nINNER JOIN organization_logins ON logins.id = organization_logins.login_id\nINNER JOIN\n organizations\n ON organization_logins.organization_id = organizations.id\nWHERE\n logins.id = ? AND NOT logins.is_deleted" + +data instance Params "getLoginOrganizations" = Params_getLoginOrganizations + { + logins_id :: Data.Int.Int32 + } + +data instance Result "getLoginOrganizations" = Result_getLoginOrganizations + { + logins_id :: !(Data.Int.Int32), + logins_display_name :: !(GHC.Base.Maybe Data.Text.Text), + logins_login_email :: !(Data.Text.Text), + logins_password_bcrypt :: !(Data.Text.Text), + logins_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + logins_timezone :: !(Pulse.Database.DBTypes.Timezone), + logins_created_at :: !((Maybe Data.Time.UTCTime)), + logins_updated_at :: !((Maybe Data.Time.UTCTime)), + organizations_id :: !(Data.Int.Int32), + organizations_display_name :: !(Data.Text.Text), + organizations_timezone :: !(Pulse.Database.DBTypes.Timezone), + organizations_created_at :: !((Maybe Data.Time.UTCTime)), + organizations_updated_at :: !((Maybe Data.Time.UTCTime)), + organization_logins_role :: !((Pulse.Database.Types.Enum "organization_role")) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getLoginOrganizations") where + toRow Params_getLoginOrganizations{..} = + [ + Database.PostgreSQL.Simple.ToField.toField logins_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getLoginOrganizations") where + fromRow = + pure Result_getLoginOrganizations + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetLoginTeams.hs b/test/golden/out/Pulse/Database/GetLoginTeams.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetLoginTeams.hs @@ -0,0 +1,68 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetLoginTeams where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_getLoginTeams :: Query "getLoginTeams" ":many" +query_getLoginTeams = Query "SELECT teams.id, teams.organization_id, teams.display_name, teams.invitation_code, teams.is_deleted, teams.created_at, teams.updated_at\nFROM logins\nINNER JOIN team_members ON logins.id = team_members.login_id\nINNER JOIN teams ON team_members.team_id = teams.id\nWHERE\n organization_id = ?\n AND logins.id = ?\n AND NOT logins.is_deleted\n AND NOT teams.is_deleted\n AND (\n teams.id IN ?\n OR ? IS null\n )\nORDER BY teams.display_name ASC" + +data instance Params "getLoginTeams" = Params_getLoginTeams + { + teams_organization_id :: Data.Int.Int32, + logins_id :: Data.Int.Int32, + teams_team_ids :: [Data.Int.Int32] + } + +data instance Result "getLoginTeams" = Result_getLoginTeams + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getLoginTeams") where + toRow Params_getLoginTeams{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id, + + Database.PostgreSQL.Simple.ToField.toField logins_id, + + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList teams_team_ids)), + + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList teams_team_ids)) + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getLoginTeams") where + fromRow = + pure Result_getLoginTeams + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetMonitors.hs b/test/golden/out/Pulse/Database/GetMonitors.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetMonitors.hs @@ -0,0 +1,89 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetMonitors where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified Data.Vector +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getMonitors :: Query "getMonitors" ":many" +query_getMonitors = Query "SELECT id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id\nFROM\n monitors\nWHERE\n monitors.organization_id = ?\n AND\n ( ?::TEXT[] IS NULL\n OR monitors.name = ANY(?::TEXT[])\n )\n AND\n ( ?::INT[] IS NULL\n OR NOT (monitors.id = ANY(?::INT[]))\n )\n AND\n ( ?::INT[] IS NULL\n OR monitors.id = ANY(?::INT[])\n )\n AND NOT monitors.is_deleted" + +data instance Params "getMonitors" = Params_getMonitors + { + monitors_organization_id :: Data.Int.Int32, + monitor_names :: GHC.Base.Maybe (Data.Vector.Vector Data.Text.Text), + exclude_monitors :: GHC.Base.Maybe (Data.Vector.Vector Data.Int.Int32), + monitor_ids :: GHC.Base.Maybe (Data.Vector.Vector Data.Int.Int32) + } + +data instance Result "getMonitors" = Result_getMonitors + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getMonitors") where + toRow Params_getMonitors{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id, + + Database.PostgreSQL.Simple.ToField.toField monitor_names, + + Database.PostgreSQL.Simple.ToField.toField monitor_names, + + Database.PostgreSQL.Simple.ToField.toField exclude_monitors, + + Database.PostgreSQL.Simple.ToField.toField exclude_monitors, + + Database.PostgreSQL.Simple.ToField.toField monitor_ids, + + Database.PostgreSQL.Simple.ToField.toField monitor_ids + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getMonitors") where + fromRow = + pure Result_getMonitors + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaAttributeAggregates.hs b/test/golden/out/Pulse/Database/GetOpcuaAttributeAggregates.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaAttributeAggregates.hs @@ -0,0 +1,83 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaAttributeAggregates where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Vector +import qualified Pulse.Database.DBTypes +import qualified Data.Time.LocalTime +import qualified GHC.Base +import qualified Data.Scientific +import qualified GHC.Types +import qualified Data.Foldable + +query_getOpcuaAttributeAggregates :: Query "getOpcuaAttributeAggregates" ":many" +query_getOpcuaAttributeAggregates = Query "SELECT\n inputs.monitor_id,\n\n aggregates.count,\n\n aggregates.min_value_integral,\n aggregates.max_value_integral,\n aggregates.avg_value_integral,\n aggregates.sum_value_integral,\n\n aggregates.min_value_float,\n aggregates.max_value_float,\n aggregates.avg_value_float,\n aggregates.sum_value_float\nFROM\n -- SQLC doesn't have a good way to pass many structured things\n -- so instead we pass a bunch of arrays which are hopefully all\n -- have the same length.\n ( SELECT\n unnest(?::INT[]) as monitor_id,\n unnest(?::INT[]) as endpoint_monitor_id,\n unnest(?::OPCUA_NODE_ID[]) as node_id,\n unnest(?::OPCUA_ATTRIBUTE_ID[]) as attribute_id,\n unnest(?::INTERVAL[]) as duration_start,\n unnest(?::INTERVAL[]) as duration_end\n ) AS inputs,\nLATERAL\n ( SELECT\n COUNT(*) as count,\n -- This looks strange but is necessary to make SQLC do the right\n -- thing, that is mark the aggregates as nullable.\n COALESCE(NULL, MIN(value_integral)) AS min_value_integral,\n COALESCE(NULL, MAX(value_integral)) AS max_value_integral,\n COALESCE(NULL, AVG(value_integral)) AS avg_value_integral,\n COALESCE(NULL, SUM(value_integral)) AS sum_value_integral,\n\n COALESCE(NULL, MIN(value_float)) AS min_value_float,\n COALESCE(NULL, MAX(value_float)) AS max_value_float,\n COALESCE(NULL, AVG(value_float)) AS avg_value_float,\n COALESCE(NULL, SUM(value_float)) AS sum_value_float\n FROM\n opcua_attribute_values\n WHERE\n opcua_attribute_values.endpoint_monitor_id = inputs.endpoint_monitor_id\n AND opcua_attribute_values.opcua_node_id = inputs.node_id\n AND opcua_attribute_values.attribute_id = inputs.attribute_id\n AND created_at >= NOW() - inputs.duration_start\n AND created_at < NOW () - inputs.duration_end\n LIMIT 1\n ) AS aggregates" + +data instance Params "getOpcuaAttributeAggregates" = Params_getOpcuaAttributeAggregates + { + monitor_ids :: Data.Vector.Vector Data.Int.Int32, + endpoint_monitor_ids :: Data.Vector.Vector Data.Int.Int32, + node_ids :: Data.Vector.Vector Pulse.Database.DBTypes.OpcuaNodeId, + attribute_ids :: Data.Vector.Vector Pulse.Database.DBTypes.OpcuaAttributeId, + duration_starts :: Data.Vector.Vector Data.Time.LocalTime.CalendarDiffTime, + duration_ends :: Data.Vector.Vector Data.Time.LocalTime.CalendarDiffTime + } + +data instance Result "getOpcuaAttributeAggregates" = Result_getOpcuaAttributeAggregates + { + monitor_id :: !(Data.Int.Int32), + count :: !(Data.Int.Int64), + min_value_integral :: !(GHC.Base.Maybe Data.Int.Int64), + max_value_integral :: !(GHC.Base.Maybe Data.Int.Int64), + avg_value_integral :: !(GHC.Base.Maybe Data.Scientific.Scientific), + sum_value_integral :: !(GHC.Base.Maybe Data.Scientific.Scientific), + min_value_float :: !(GHC.Base.Maybe GHC.Types.Double), + max_value_float :: !(GHC.Base.Maybe GHC.Types.Double), + avg_value_float :: !(GHC.Base.Maybe GHC.Types.Double), + sum_value_float :: !(GHC.Base.Maybe GHC.Types.Double) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaAttributeAggregates") where + toRow Params_getOpcuaAttributeAggregates{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitor_ids, + + Database.PostgreSQL.Simple.ToField.toField endpoint_monitor_ids, + + Database.PostgreSQL.Simple.ToField.toField node_ids, + + Database.PostgreSQL.Simple.ToField.toField attribute_ids, + + Database.PostgreSQL.Simple.ToField.toField duration_starts, + + Database.PostgreSQL.Simple.ToField.toField duration_ends + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaAttributeAggregates") where + fromRow = + pure Result_getOpcuaAttributeAggregates + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaAttributeValuesForTimeRange.hs b/test/golden/out/Pulse/Database/GetOpcuaAttributeValuesForTimeRange.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaAttributeValuesForTimeRange.hs @@ -0,0 +1,81 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaAttributeValuesForTimeRange where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Pulse.Database.DBTypes +import qualified Data.Time +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Text +import qualified Data.Foldable + +query_getOpcuaAttributeValuesForTimeRange :: Query "getOpcuaAttributeValuesForTimeRange" ":many" +query_getOpcuaAttributeValuesForTimeRange = Query "SELECT\n endpoint_monitor_id,\n opcua_node_id,\n attribute_id,\n value_type,\n value_integral,\n value_float,\n value_bool,\n value_string,\n value_status_code,\n value,\n created_at\nFROM opcua_attribute_values\nWHERE\n endpoint_monitor_id = ?\n AND opcua_node_id = ?::OPCUA_NODE_ID\n AND attribute_id = ?::OPCUA_ATTRIBUTE_ID\n AND created_at >= ?\n AND created_at <= ?\nORDER BY created_at DESC" + +data instance Params "getOpcuaAttributeValuesForTimeRange" = Params_getOpcuaAttributeValuesForTimeRange + { + opcua_attribute_values_endpoint_monitor_id :: Data.Int.Int32, + opcua_node_id :: Pulse.Database.DBTypes.OpcuaNodeId, + attribute_id :: Pulse.Database.DBTypes.OpcuaAttributeId, + opcua_attribute_values_start_time :: (Maybe Data.Time.UTCTime), + opcua_attribute_values_end_time :: (Maybe Data.Time.UTCTime) + } + +data instance Result "getOpcuaAttributeValuesForTimeRange" = Result_getOpcuaAttributeValuesForTimeRange + { + opcua_attribute_values_endpoint_monitor_id :: !(Data.Int.Int32), + opcua_attribute_values_opcua_node_id :: !(Pulse.Database.DBTypes.OpcuaNodeId), + opcua_attribute_values_attribute_id :: !(Pulse.Database.DBTypes.OpcuaAttributeId), + opcua_attribute_values_value_type :: !(Pulse.Database.DBTypes.OpcuaDataValueType), + opcua_attribute_values_value_integral :: !(GHC.Base.Maybe Data.Int.Int64), + opcua_attribute_values_value_float :: !(GHC.Base.Maybe GHC.Types.Double), + opcua_attribute_values_value_bool :: !(GHC.Base.Maybe GHC.Types.Bool), + opcua_attribute_values_value_string :: !(GHC.Base.Maybe Data.Text.Text), + opcua_attribute_values_value_status_code :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_attribute_values_value :: !(Pulse.Database.DBTypes.OpcuaDataValue), + opcua_attribute_values_created_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaAttributeValuesForTimeRange") where + toRow Params_getOpcuaAttributeValuesForTimeRange{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_endpoint_monitor_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_id, + + Database.PostgreSQL.Simple.ToField.toField attribute_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_start_time, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_end_time + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaAttributeValuesForTimeRange") where + fromRow = + pure Result_getOpcuaAttributeValuesForTimeRange + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaEndpointCertificates.hs b/test/golden/out/Pulse/Database/GetOpcuaEndpointCertificates.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaEndpointCertificates.hs @@ -0,0 +1,78 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaEndpointCertificates where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified GHC.Base +import qualified Data.Vector +import qualified Pulse.Database.Types +import qualified Data.Text +import qualified Data.Time +import qualified Data.ByteString +import qualified Database.PostgreSQL.Simple +import qualified Data.Foldable + +query_getOpcuaEndpointCertificates :: Query "getOpcuaEndpointCertificates" ":many" +query_getOpcuaEndpointCertificates = Query "SELECT\n id, organization_id, provided_by, subject, issuer, signature, valid_from, valid_to, certificate, private_key, created_at, updated_at\nFROM\n opcua_endpoint_certificates\nWHERE\n organization_id = ?\n AND\n ( ?::INT[] IS NULL\n OR opcua_endpoint_certificates.id = ANY(?::INT [])\n )" + +data instance Params "getOpcuaEndpointCertificates" = Params_getOpcuaEndpointCertificates + { + opcua_endpoint_certificates_organization_id :: Data.Int.Int32, + certificate_ids :: GHC.Base.Maybe (Data.Vector.Vector Data.Int.Int32) + } + +data instance Result "getOpcuaEndpointCertificates" = Result_getOpcuaEndpointCertificates + { + opcua_endpoint_certificates_id :: !(Data.Int.Int32), + opcua_endpoint_certificates_organization_id :: !(Data.Int.Int32), + opcua_endpoint_certificates_provided_by :: !((Pulse.Database.Types.Enum "certificate_provider")), + opcua_endpoint_certificates_subject :: !(Data.Text.Text), + opcua_endpoint_certificates_issuer :: !(Data.Text.Text), + opcua_endpoint_certificates_signature :: !(Data.Text.Text), + opcua_endpoint_certificates_valid_from :: !(Data.Time.UTCTime), + opcua_endpoint_certificates_valid_to :: !(Data.Time.UTCTime), + opcua_endpoint_certificates_certificate :: !((Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString)), + opcua_endpoint_certificates_private_key :: !((Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString)), + opcua_endpoint_certificates_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_certificates_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaEndpointCertificates") where + toRow Params_getOpcuaEndpointCertificates{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_organization_id, + + Database.PostgreSQL.Simple.ToField.toField certificate_ids, + + Database.PostgreSQL.Simple.ToField.toField certificate_ids + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaEndpointCertificates") where + fromRow = + pure Result_getOpcuaEndpointCertificates + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaEndpointCredentials.hs b/test/golden/out/Pulse/Database/GetOpcuaEndpointCredentials.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaEndpointCredentials.hs @@ -0,0 +1,65 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaEndpointCredentials where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified GHC.Base +import qualified Data.Vector +import qualified Data.Text +import qualified Data.Time +import qualified Data.Foldable + +query_getOpcuaEndpointCredentials :: Query "getOpcuaEndpointCredentials" ":many" +query_getOpcuaEndpointCredentials = Query "SELECT\n id, organization_id, name, username, password, created_at, updated_at\nFROM\n opcua_endpoint_credentials\nWHERE\n organization_id = ?\n AND\n ( ?::INT[] IS NULL\n OR opcua_endpoint_credentials.id = ANY(?::INT [])\n )" + +data instance Params "getOpcuaEndpointCredentials" = Params_getOpcuaEndpointCredentials + { + opcua_endpoint_credentials_organization_id :: Data.Int.Int32, + credential_ids :: GHC.Base.Maybe (Data.Vector.Vector Data.Int.Int32) + } + +data instance Result "getOpcuaEndpointCredentials" = Result_getOpcuaEndpointCredentials + { + opcua_endpoint_credentials_id :: !(Data.Int.Int32), + opcua_endpoint_credentials_organization_id :: !(Data.Int.Int32), + opcua_endpoint_credentials_name :: !(Data.Text.Text), + opcua_endpoint_credentials_username :: !(Data.Text.Text), + opcua_endpoint_credentials_password :: !(Data.Text.Text), + opcua_endpoint_credentials_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_credentials_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaEndpointCredentials") where + toRow Params_getOpcuaEndpointCredentials{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_credentials_organization_id, + + Database.PostgreSQL.Simple.ToField.toField credential_ids, + + Database.PostgreSQL.Simple.ToField.toField credential_ids + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaEndpointCredentials") where + fromRow = + pure Result_getOpcuaEndpointCredentials + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaEndpointMonitors.hs b/test/golden/out/Pulse/Database/GetOpcuaEndpointMonitors.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaEndpointMonitors.hs @@ -0,0 +1,131 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaEndpointMonitors where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified Data.Vector +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getOpcuaEndpointMonitors :: Query "getOpcuaEndpointMonitors" ":many" +query_getOpcuaEndpointMonitors = Query "SELECT monitors.id, monitors.organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_endpoint_monitors.id, endpoint, mode, policy, certificate, credentials, incident_message_template, latest_connection_attempt, opcua_endpoint_monitors.created_at, opcua_endpoint_monitors.updated_at, incidents.id, incidents.organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, incidents.created_at, incidents.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_endpoint_monitors ON monitors.id = opcua_endpoint_monitors.id\nLEFT JOIN\n incidents ON\n incidents.organization_id = monitors.organization_id\n AND incidents.failing_monitor = opcua_endpoint_monitors.id\n AND status <> 'resolved'\nWHERE\n monitors.organization_id = ?\n AND monitors.type = 'opcua_endpoint'\n AND\n ( ?::TEXT[] IS NULL\n OR opcua_endpoint_monitors.endpoint = ANY(?::TEXT[])\n )\n AND\n ( ?::INT[] IS NULL\n OR monitors.id = ANY(?::INT[])\n )\n AND\n ( ?::INT[] IS NULL\n OR NOT (monitors.id = ANY(?::INT[]))\n )\n AND NOT monitors.is_deleted" + +data instance Params "getOpcuaEndpointMonitors" = Params_getOpcuaEndpointMonitors + { + monitors_organization_id :: Data.Int.Int32, + endpoints :: GHC.Base.Maybe (Data.Vector.Vector Data.Text.Text), + monitor_ids :: GHC.Base.Maybe (Data.Vector.Vector Data.Int.Int32), + exclude_monitors :: GHC.Base.Maybe (Data.Vector.Vector Data.Int.Int32) + } + +data instance Result "getOpcuaEndpointMonitors" = Result_getOpcuaEndpointMonitors + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + opcua_endpoint_monitors_id :: !(Data.Int.Int32), + opcua_endpoint_monitors_endpoint :: !(Data.Text.Text), + opcua_endpoint_monitors_mode :: !((Pulse.Database.Types.Enum "opcua_security_mode")), + opcua_endpoint_monitors_policy :: !((Pulse.Database.Types.Enum "opcua_security_policy")), + opcua_endpoint_monitors_certificate :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_credentials :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_monitors_latest_connection_attempt :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + incidents_id :: !(GHC.Base.Maybe Data.Int.Int64), + incidents_organization_id :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_display_name :: !(GHC.Base.Maybe Data.Text.Text), + incidents_description :: !(GHC.Base.Maybe Data.Text.Text), + incidents_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_status :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "incident_status"))), + incidents_lead_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_acknowledged_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_unacknowledged_at :: !((Maybe Data.Time.UTCTime)), + incidents_created_at :: !((Maybe Data.Time.UTCTime)), + incidents_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaEndpointMonitors") where + toRow Params_getOpcuaEndpointMonitors{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id, + + Database.PostgreSQL.Simple.ToField.toField endpoints, + + Database.PostgreSQL.Simple.ToField.toField endpoints, + + Database.PostgreSQL.Simple.ToField.toField monitor_ids, + + Database.PostgreSQL.Simple.ToField.toField monitor_ids, + + Database.PostgreSQL.Simple.ToField.toField exclude_monitors, + + Database.PostgreSQL.Simple.ToField.toField exclude_monitors + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaEndpointMonitors") where + fromRow = + pure Result_getOpcuaEndpointMonitors + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaEndpointMonitorsToCheck.hs b/test/golden/out/Pulse/Database/GetOpcuaEndpointMonitorsToCheck.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaEndpointMonitorsToCheck.hs @@ -0,0 +1,93 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaEndpointMonitorsToCheck where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified GHC.Base +import qualified Data.Foldable + +query_getOpcuaEndpointMonitorsToCheck :: Query "getOpcuaEndpointMonitorsToCheck" ":many" +query_getOpcuaEndpointMonitorsToCheck = Query "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_endpoint_monitors.id, endpoint, mode, policy, certificate, credentials, incident_message_template, latest_connection_attempt, opcua_endpoint_monitors.created_at, opcua_endpoint_monitors.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_endpoint_monitors ON monitors.id = opcua_endpoint_monitors.id\nWHERE\n monitors.organization_id = ?\n AND monitors.type = 'opcua_endpoint'\n AND monitors.is_active\n AND NOT monitors.is_deleted\n AND\n (\n monitors.last_checked IS null\n OR monitors.healthiness = 'unknown'\n OR (\n monitors.healthiness = 'unhealthy'\n AND monitors.last_checked + '3 seconds' < NOW()\n )\n OR (\n monitors.healthiness = 'healthy'\n AND monitors.last_checked + '10 seconds' < NOW()\n )\n )" + +data instance Params "getOpcuaEndpointMonitorsToCheck" = Params_getOpcuaEndpointMonitorsToCheck + { + monitors_organization_id :: Data.Int.Int32 + } + +data instance Result "getOpcuaEndpointMonitorsToCheck" = Result_getOpcuaEndpointMonitorsToCheck + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + opcua_endpoint_monitors_id :: !(Data.Int.Int32), + opcua_endpoint_monitors_endpoint :: !(Data.Text.Text), + opcua_endpoint_monitors_mode :: !((Pulse.Database.Types.Enum "opcua_security_mode")), + opcua_endpoint_monitors_policy :: !((Pulse.Database.Types.Enum "opcua_security_policy")), + opcua_endpoint_monitors_certificate :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_credentials :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_monitors_latest_connection_attempt :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaEndpointMonitorsToCheck") where + toRow Params_getOpcuaEndpointMonitorsToCheck{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaEndpointMonitorsToCheck") where + fromRow = + pure Result_getOpcuaEndpointMonitorsToCheck + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaEndpointMonitorsToSample.hs b/test/golden/out/Pulse/Database/GetOpcuaEndpointMonitorsToSample.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaEndpointMonitorsToSample.hs @@ -0,0 +1,133 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaEndpointMonitorsToSample where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified GHC.Base +import qualified Data.ByteString +import qualified Database.PostgreSQL.Simple +import qualified Data.Foldable + +query_getOpcuaEndpointMonitorsToSample :: Query "getOpcuaEndpointMonitorsToSample" ":many" +query_getOpcuaEndpointMonitorsToSample = Query "SELECT monitors.id, monitors.organization_id, monitors.name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_endpoint_monitors.id, endpoint, mode, policy, opcua_endpoint_monitors.certificate, credentials, incident_message_template, latest_connection_attempt, opcua_endpoint_monitors.created_at, opcua_endpoint_monitors.updated_at, opcua_endpoint_credentials.id, opcua_endpoint_credentials.organization_id, opcua_endpoint_credentials.name, username, password, opcua_endpoint_credentials.created_at, opcua_endpoint_credentials.updated_at, opcua_endpoint_certificates.id, opcua_endpoint_certificates.organization_id, provided_by, subject, issuer, signature, valid_from, valid_to, opcua_endpoint_certificates.certificate, private_key, opcua_endpoint_certificates.created_at, opcua_endpoint_certificates.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_endpoint_monitors ON monitors.id = opcua_endpoint_monitors.id\nLEFT JOIN\n opcua_endpoint_credentials ON monitors.id = opcua_endpoint_credentials.id\nLEFT JOIN\n opcua_endpoint_certificates ON monitors.id = opcua_endpoint_certificates.id\nWHERE\n monitors.organization_id = ?\n AND monitors.type = 'opcua_endpoint'\n -- We used to only sample \"active\" endpoints. We continue to sample active\n -- OPCUA Endpoints but we do not raise any incidents for them, if they are\n -- failing.\n --\n -- AND monitors.is_active\n AND NOT monitors.is_deleted" + +data instance Params "getOpcuaEndpointMonitorsToSample" = Params_getOpcuaEndpointMonitorsToSample + { + monitors_organization_id :: Data.Int.Int32 + } + +data instance Result "getOpcuaEndpointMonitorsToSample" = Result_getOpcuaEndpointMonitorsToSample + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + opcua_endpoint_monitors_id :: !(Data.Int.Int32), + opcua_endpoint_monitors_endpoint :: !(Data.Text.Text), + opcua_endpoint_monitors_mode :: !((Pulse.Database.Types.Enum "opcua_security_mode")), + opcua_endpoint_monitors_policy :: !((Pulse.Database.Types.Enum "opcua_security_policy")), + opcua_endpoint_monitors_certificate :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_credentials :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_monitors_latest_connection_attempt :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_credentials_id :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_credentials_organization_id :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_credentials_name :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_credentials_username :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_credentials_password :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_credentials_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_credentials_updated_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_certificates_id :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_certificates_organization_id :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_certificates_provided_by :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "certificate_provider"))), + opcua_endpoint_certificates_subject :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_certificates_issuer :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_certificates_signature :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_certificates_valid_from :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_certificates_valid_to :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_certificates_certificate :: !((Maybe (Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString))), + opcua_endpoint_certificates_private_key :: !((Maybe (Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString))), + opcua_endpoint_certificates_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_certificates_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaEndpointMonitorsToSample") where + toRow Params_getOpcuaEndpointMonitorsToSample{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaEndpointMonitorsToSample") where + fromRow = + pure Result_getOpcuaEndpointMonitorsToSample + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaNodeMonitors.hs b/test/golden/out/Pulse/Database/GetOpcuaNodeMonitors.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaNodeMonitors.hs @@ -0,0 +1,156 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaNodeMonitors where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified GHC.Base +import qualified Data.Vector +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Pulse.Database.DBTypes +import qualified Data.Time.LocalTime +import qualified Data.Foldable + +query_getOpcuaNodeMonitors :: Query "getOpcuaNodeMonitors" ":many" +query_getOpcuaNodeMonitors = Query "SELECT monitors.id, monitors.organization_id, monitors.name, monitors.type, monitors.healthiness, monitors.monitor_group, monitors.threshold_failures, monitors.is_active, monitors.is_deleted, monitors.last_checked, monitors.created_at, monitors.updated_at, monitors.escalation_policy_id, opcua_node_monitors.id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, opcua_node_monitors.created_at, opcua_node_monitors.updated_at, endpoint_monitor.id, endpoint_monitor.organization_id, endpoint_monitor.name, endpoint_monitor.type, endpoint_monitor.healthiness, endpoint_monitor.monitor_group, endpoint_monitor.threshold_failures, endpoint_monitor.is_active, endpoint_monitor.is_deleted, endpoint_monitor.last_checked, endpoint_monitor.created_at, endpoint_monitor.updated_at, endpoint_monitor.escalation_policy_id, incidents.id, incidents.organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, incidents.created_at, incidents.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_node_monitors ON monitors.id = opcua_node_monitors.id\nINNER JOIN\n monitors AS endpoint_monitor ON monitors.id = opcua_node_monitors.endpoint_monitor_id\nLEFT JOIN\n incidents ON\n incidents.organization_id = monitors.organization_id\n AND incidents.failing_monitor = opcua_node_monitors.id\n AND status <> 'resolved'\nWHERE\n monitors.organization_id = ?\n AND monitors.type = 'opcua_node'\n AND\n ( ?::INT[] IS NULL\n OR monitors.id = ANY(?::INT[])\n )\n AND\n ( ?::INT[] IS NULL\n OR NOT (monitors.id = ANY(?::INT[]))\n )\n AND NOT monitors.is_deleted" + +data instance Params "getOpcuaNodeMonitors" = Params_getOpcuaNodeMonitors + { + monitors_organization_id :: Data.Int.Int32, + monitor_ids :: GHC.Base.Maybe (Data.Vector.Vector Data.Int.Int32), + exclude_monitors :: GHC.Base.Maybe (Data.Vector.Vector Data.Int.Int32) + } + +data instance Result "getOpcuaNodeMonitors" = Result_getOpcuaNodeMonitors + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + opcua_node_monitors_id :: !(Data.Int.Int32), + opcua_node_monitors_endpoint_monitor_id :: !(Data.Int.Int32), + opcua_node_monitors_opcua_node_id :: !(Pulse.Database.DBTypes.OpcuaNodeId), + opcua_node_monitors_aggregation :: !((Pulse.Database.Types.Enum "check_aggregation")), + opcua_node_monitors_operation :: !((Pulse.Database.Types.Enum "check_op")), + opcua_node_monitors_operand :: !(Data.Text.Text), + opcua_node_monitors_duration :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_frequency :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_node_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_node_monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + incidents_id :: !(GHC.Base.Maybe Data.Int.Int64), + incidents_organization_id :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_display_name :: !(GHC.Base.Maybe Data.Text.Text), + incidents_description :: !(GHC.Base.Maybe Data.Text.Text), + incidents_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_status :: !(GHC.Base.Maybe ((Pulse.Database.Types.Enum "incident_status"))), + incidents_lead_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_acknowledged_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_unacknowledged_at :: !((Maybe Data.Time.UTCTime)), + incidents_created_at :: !((Maybe Data.Time.UTCTime)), + incidents_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaNodeMonitors") where + toRow Params_getOpcuaNodeMonitors{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id, + + Database.PostgreSQL.Simple.ToField.toField monitor_ids, + + Database.PostgreSQL.Simple.ToField.toField monitor_ids, + + Database.PostgreSQL.Simple.ToField.toField exclude_monitors, + + Database.PostgreSQL.Simple.ToField.toField exclude_monitors + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaNodeMonitors") where + fromRow = + pure Result_getOpcuaNodeMonitors + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaNodeMonitorsToCheck.hs b/test/golden/out/Pulse/Database/GetOpcuaNodeMonitorsToCheck.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaNodeMonitorsToCheck.hs @@ -0,0 +1,103 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaNodeMonitorsToCheck where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified Data.Time +import qualified Pulse.Database.DBTypes +import qualified Data.Time.LocalTime +import qualified Data.Foldable + +query_getOpcuaNodeMonitorsToCheck :: Query "getOpcuaNodeMonitorsToCheck" ":many" +query_getOpcuaNodeMonitorsToCheck = Query "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_node_monitors.id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, opcua_node_monitors.created_at, opcua_node_monitors.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_node_monitors ON monitors.id = opcua_node_monitors.id\nWHERE\n monitors.organization_id = ?\n AND monitors.type = 'opcua_node'\n AND monitors.is_active\n AND NOT monitors.is_deleted\n AND opcua_node_monitors.endpoint_monitor_id IN ?\n AND\n ( COALESCE (?::BOOLEAN, false)\n OR monitors.last_checked IS NULL\n OR monitors.last_checked + opcua_node_monitors.frequency <= NOW ()\n )" + +data instance Params "getOpcuaNodeMonitorsToCheck" = Params_getOpcuaNodeMonitorsToCheck + { + monitors_organization_id :: Data.Int.Int32, + opcua_node_monitors_endpoint_monitor_ids :: [Data.Int.Int32], + override :: GHC.Base.Maybe GHC.Types.Bool + } + +data instance Result "getOpcuaNodeMonitorsToCheck" = Result_getOpcuaNodeMonitorsToCheck + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + opcua_node_monitors_id :: !(Data.Int.Int32), + opcua_node_monitors_endpoint_monitor_id :: !(Data.Int.Int32), + opcua_node_monitors_opcua_node_id :: !(Pulse.Database.DBTypes.OpcuaNodeId), + opcua_node_monitors_aggregation :: !((Pulse.Database.Types.Enum "check_aggregation")), + opcua_node_monitors_operation :: !((Pulse.Database.Types.Enum "check_op")), + opcua_node_monitors_operand :: !(Data.Text.Text), + opcua_node_monitors_duration :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_frequency :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_node_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_node_monitors_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaNodeMonitorsToCheck") where + toRow Params_getOpcuaNodeMonitorsToCheck{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id, + + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList opcua_node_monitors_endpoint_monitor_ids)), + + Database.PostgreSQL.Simple.ToField.toField override + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaNodeMonitorsToCheck") where + fromRow = + pure Result_getOpcuaNodeMonitorsToCheck + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOpcuaNodeMonitorsToSample.hs b/test/golden/out/Pulse/Database/GetOpcuaNodeMonitorsToSample.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOpcuaNodeMonitorsToSample.hs @@ -0,0 +1,100 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOpcuaNodeMonitorsToSample where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Pulse.Database.DBTypes +import qualified Data.Time.LocalTime +import qualified GHC.Base +import qualified Data.Foldable + +query_getOpcuaNodeMonitorsToSample :: Query "getOpcuaNodeMonitorsToSample" ":many" +query_getOpcuaNodeMonitorsToSample = Query "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, monitors.updated_at, escalation_policy_id, opcua_node_monitors.id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, opcua_node_monitors.created_at, opcua_node_monitors.updated_at\nFROM\n monitors\nINNER JOIN\n opcua_node_monitors ON monitors.id = opcua_node_monitors.id\nWHERE\n monitors.organization_id = ?\n AND monitors.type = 'opcua_node'\n AND NOT monitors.is_deleted\n -- We used to only sample \"active\" endpoints. We continue to sample active\n -- OPCUA Endpoints but we do not raise any incidents for them, if they are\n -- failing.\n --\n -- AND monitors.is_active\n AND opcua_node_monitors.endpoint_monitor_id IN ?" + +data instance Params "getOpcuaNodeMonitorsToSample" = Params_getOpcuaNodeMonitorsToSample + { + monitors_organization_id :: Data.Int.Int32, + opcua_node_monitors_endpoint_monitor_ids :: [Data.Int.Int32] + } + +data instance Result "getOpcuaNodeMonitorsToSample" = Result_getOpcuaNodeMonitorsToSample + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + opcua_node_monitors_id :: !(Data.Int.Int32), + opcua_node_monitors_endpoint_monitor_id :: !(Data.Int.Int32), + opcua_node_monitors_opcua_node_id :: !(Pulse.Database.DBTypes.OpcuaNodeId), + opcua_node_monitors_aggregation :: !((Pulse.Database.Types.Enum "check_aggregation")), + opcua_node_monitors_operation :: !((Pulse.Database.Types.Enum "check_op")), + opcua_node_monitors_operand :: !(Data.Text.Text), + opcua_node_monitors_duration :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_frequency :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_node_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_node_monitors_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOpcuaNodeMonitorsToSample") where + toRow Params_getOpcuaNodeMonitorsToSample{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id, + + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList opcua_node_monitors_endpoint_monitor_ids)) + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOpcuaNodeMonitorsToSample") where + fromRow = + pure Result_getOpcuaNodeMonitorsToSample + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetOrganizations.hs b/test/golden/out/Pulse/Database/GetOrganizations.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetOrganizations.hs @@ -0,0 +1,52 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOrganizations where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.DBTypes +import qualified Data.Time +import qualified Data.Foldable + +query_getOrganizations :: Query "getOrganizations" ":many" +query_getOrganizations = Query "SELECT id, display_name, timezone, created_at, updated_at FROM organizations" + +data instance Params "getOrganizations" = Params_getOrganizations + { + } + +data instance Result "getOrganizations" = Result_getOrganizations + { + organizations_id :: !(Data.Int.Int32), + organizations_display_name :: !(Data.Text.Text), + organizations_timezone :: !(Pulse.Database.DBTypes.Timezone), + organizations_created_at :: !((Maybe Data.Time.UTCTime)), + organizations_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOrganizations") where + toRow Params_getOrganizations{} = + [ ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOrganizations") where + fromRow = + pure Result_getOrganizations + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetRecoveredHeartbearMonitors.hs b/test/golden/out/Pulse/Database/GetRecoveredHeartbearMonitors.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetRecoveredHeartbearMonitors.hs @@ -0,0 +1,83 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetRecoveredHeartbearMonitors where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Time.LocalTime +import qualified Data.Foldable + +query_getRecoveredHeartbearMonitors :: Query "getRecoveredHeartbearMonitors" ":many" +query_getRecoveredHeartbearMonitors = Query "SELECT monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, updated_at, escalation_policy_id, heartbeat_monitors.id, heartbeat_slug, last_heartbeat, expected_interval, heartbeat_monitors.created_at\nFROM\n monitors\nINNER JOIN\n heartbeat_monitors ON monitors.id = heartbeat_monitors.id\nWHERE\n monitors.organization_id = ?\n AND monitors.type = 'heartbeat'\n AND monitors.healthiness IN ('unknown', 'unhealthy')\n AND NOT monitors.is_deleted\n AND heartbeat_monitors.last_heartbeat + heartbeat_monitors.expected_interval >= NOW()" + +data instance Params "getRecoveredHeartbearMonitors" = Params_getRecoveredHeartbearMonitors + { + monitors_organization_id :: Data.Int.Int32 + } + +data instance Result "getRecoveredHeartbearMonitors" = Result_getRecoveredHeartbearMonitors + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + heartbeat_monitors_id :: !(Data.Int.Int32), + heartbeat_monitors_heartbeat_slug :: !(Data.Text.Text), + heartbeat_monitors_last_heartbeat :: !((Maybe Data.Time.UTCTime)), + heartbeat_monitors_expected_interval :: !(Data.Time.LocalTime.CalendarDiffTime), + heartbeat_monitors_created_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getRecoveredHeartbearMonitors") where + toRow Params_getRecoveredHeartbearMonitors{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getRecoveredHeartbearMonitors") where + fromRow = + pure Result_getRecoveredHeartbearMonitors + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetResolvedIncidentsForNotification.hs b/test/golden/out/Pulse/Database/GetResolvedIncidentsForNotification.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetResolvedIncidentsForNotification.hs @@ -0,0 +1,86 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetResolvedIncidentsForNotification where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Time +import qualified GHC.Types +import qualified Data.Text +import qualified GHC.Base +import qualified Pulse.Database.Types +import qualified Data.Foldable + +query_getResolvedIncidentsForNotification :: Query "getResolvedIncidentsForNotification" ":many" +query_getResolvedIncidentsForNotification = Query "SELECT\n ie.id, ie.escalation_policy_id, ie.current_step, ie.escalation_started_at, ie.next_escalation_at, ie.is_active, ie.threshold, ie.failed_checks, ie.incident_notification_sent_at, ie.resolved_notification_sent_at, ie.acknowledged_notification_sent_at, ie.created_at, ie.updated_at,\n i.id,\n i.organization_id,\n i.display_name,\n i.description,\n i.failing_monitor,\n i.status,\n i.created_at,\n ep.name as escalation_policy_name\nFROM incident_escalations ie\nINNER JOIN incidents i ON ie.id = i.id\nINNER JOIN escalation_policies ep ON ie.escalation_policy_id = ep.id\nWHERE\n i.status = 'resolved'\n AND ie.incident_notification_sent_at IS NOT NULL\n AND ie.resolved_notification_sent_at IS NULL\nORDER BY i.updated_at ASC\nLIMIT 100" + +data instance Params "getResolvedIncidentsForNotification" = Params_getResolvedIncidentsForNotification + { + } + +data instance Result "getResolvedIncidentsForNotification" = Result_getResolvedIncidentsForNotification + { + incident_escalations_id :: !(Data.Int.Int64), + incident_escalations_escalation_policy_id :: !(Data.Int.Int32), + incident_escalations_current_step :: !(Data.Int.Int32), + incident_escalations_escalation_started_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_next_escalation_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_is_active :: !(GHC.Types.Bool), + incident_escalations_threshold :: !(Data.Int.Int32), + incident_escalations_failed_checks :: !(Data.Int.Int32), + incident_escalations_incident_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_resolved_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_acknowledged_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_created_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_updated_at :: !((Maybe Data.Time.UTCTime)), + incidents_id :: !(Data.Int.Int64), + incidents_organization_id :: !(Data.Int.Int32), + incidents_display_name :: !(Data.Text.Text), + incidents_description :: !(GHC.Base.Maybe Data.Text.Text), + incidents_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_status :: !((Pulse.Database.Types.Enum "incident_status")), + incidents_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_policies_escalation_policy_name :: !(Data.Text.Text) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getResolvedIncidentsForNotification") where + toRow Params_getResolvedIncidentsForNotification{} = + [ ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getResolvedIncidentsForNotification") where + fromRow = + pure Result_getResolvedIncidentsForNotification + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetSeverities.hs b/test/golden/out/Pulse/Database/GetSeverities.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetSeverities.hs @@ -0,0 +1,61 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetSeverities where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getSeverities :: Query "getSeverities" ":many" +query_getSeverities = Query "SELECT id, team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert, created_at, updated_at FROM severities\nWHERE team_id = ?\nORDER BY name ASC" + +data instance Params "getSeverities" = Params_getSeverities + { + severities_team_id :: Data.Int.Int32 + } + +data instance Result "getSeverities" = Result_getSeverities + { + severities_id :: !(Data.Int.Int32), + severities_team_id :: !(Data.Int.Int32), + severities_name :: !(Data.Text.Text), + severities_notify_by_email :: !(GHC.Types.Bool), + severities_notify_by_push :: !(GHC.Types.Bool), + severities_notify_by_critical_alert :: !(GHC.Types.Bool), + severities_created_at :: !((Maybe Data.Time.UTCTime)), + severities_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getSeverities") where + toRow Params_getSeverities{..} = + [ + Database.PostgreSQL.Simple.ToField.toField severities_team_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getSeverities") where + fromRow = + pure Result_getSeverities + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetSeverityById.hs b/test/golden/out/Pulse/Database/GetSeverityById.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetSeverityById.hs @@ -0,0 +1,61 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetSeverityById where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getSeverityById :: Query "getSeverityById" ":one" +query_getSeverityById = Query "SELECT id, team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert, created_at, updated_at FROM severities\nWHERE id = ?" + +data instance Params "getSeverityById" = Params_getSeverityById + { + severities_id :: Data.Int.Int32 + } + +data instance Result "getSeverityById" = Result_getSeverityById + { + severities_id :: !(Data.Int.Int32), + severities_team_id :: !(Data.Int.Int32), + severities_name :: !(Data.Text.Text), + severities_notify_by_email :: !(GHC.Types.Bool), + severities_notify_by_push :: !(GHC.Types.Bool), + severities_notify_by_critical_alert :: !(GHC.Types.Bool), + severities_created_at :: !((Maybe Data.Time.UTCTime)), + severities_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getSeverityById") where + toRow Params_getSeverityById{..} = + [ + Database.PostgreSQL.Simple.ToField.toField severities_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getSeverityById") where + fromRow = + pure Result_getSeverityById + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetTeamById.hs b/test/golden/out/Pulse/Database/GetTeamById.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetTeamById.hs @@ -0,0 +1,63 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeamById where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_getTeamById :: Query "getTeamById" ":one" +query_getTeamById = Query "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams\nWHERE organization_id = ? AND id = ? AND NOT is_deleted" + +data instance Params "getTeamById" = Params_getTeamById + { + teams_organization_id :: Data.Int.Int32, + teams_id :: Data.Int.Int32 + } + +data instance Result "getTeamById" = Result_getTeamById + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeamById") where + toRow Params_getTeamById{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id, + + Database.PostgreSQL.Simple.ToField.toField teams_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeamById") where + fromRow = + pure Result_getTeamById + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetTeamByInvitationCode.hs b/test/golden/out/Pulse/Database/GetTeamByInvitationCode.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetTeamByInvitationCode.hs @@ -0,0 +1,71 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeamByInvitationCode where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Text +import qualified Data.Int +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Pulse.Database.DBTypes +import qualified Data.Foldable + +query_getTeamByInvitationCode :: Query "getTeamByInvitationCode" ":one" +query_getTeamByInvitationCode = Query "SELECT teams.id, organization_id, teams.display_name, invitation_code, is_deleted, teams.created_at, teams.updated_at, organizations.id, organizations.display_name, timezone, organizations.created_at, organizations.updated_at\nFROM teams\nINNER JOIN organizations ON teams.organization_id = organizations.id\nWHERE invitation_code = ? AND NOT is_deleted" + +data instance Params "getTeamByInvitationCode" = Params_getTeamByInvitationCode + { + teams_invitation_code :: Data.Text.Text + } + +data instance Result "getTeamByInvitationCode" = Result_getTeamByInvitationCode + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)), + organizations_id :: !(Data.Int.Int32), + organizations_display_name :: !(Data.Text.Text), + organizations_timezone :: !(Pulse.Database.DBTypes.Timezone), + organizations_created_at :: !((Maybe Data.Time.UTCTime)), + organizations_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeamByInvitationCode") where + toRow Params_getTeamByInvitationCode{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_invitation_code + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeamByInvitationCode") where + fromRow = + pure Result_getTeamByInvitationCode + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetTeamByName.hs b/test/golden/out/Pulse/Database/GetTeamByName.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetTeamByName.hs @@ -0,0 +1,63 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeamByName where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_getTeamByName :: Query "getTeamByName" ":one" +query_getTeamByName = Query "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams\nWHERE organization_id = ? AND display_name = ?" + +data instance Params "getTeamByName" = Params_getTeamByName + { + teams_organization_id :: Data.Int.Int32, + teams_display_name :: Data.Text.Text + } + +data instance Result "getTeamByName" = Result_getTeamByName + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeamByName") where + toRow Params_getTeamByName{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id, + + Database.PostgreSQL.Simple.ToField.toField teams_display_name + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeamByName") where + fromRow = + pure Result_getTeamByName + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetTeamMembers.hs b/test/golden/out/Pulse/Database/GetTeamMembers.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetTeamMembers.hs @@ -0,0 +1,74 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeamMembers where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Pulse.Database.DBTypes +import qualified Data.Time +import qualified Pulse.Database.Types +import qualified Data.Foldable + +query_getTeamMembers :: Query "getTeamMembers" ":many" +query_getTeamMembers = Query "SELECT id, display_name, login_email, password_bcrypt, is_deleted, timezone, logins.created_at, logins.updated_at, team_id, login_id, role, team_members.created_at, team_members.updated_at\nFROM logins\nINNER JOIN team_members ON logins.id = team_members.login_id\nWHERE team_id = ?" + +data instance Params "getTeamMembers" = Params_getTeamMembers + { + team_members_team_id :: Data.Int.Int32 + } + +data instance Result "getTeamMembers" = Result_getTeamMembers + { + logins_id :: !(Data.Int.Int32), + logins_display_name :: !(GHC.Base.Maybe Data.Text.Text), + logins_login_email :: !(Data.Text.Text), + logins_password_bcrypt :: !(Data.Text.Text), + logins_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + logins_timezone :: !(Pulse.Database.DBTypes.Timezone), + logins_created_at :: !((Maybe Data.Time.UTCTime)), + logins_updated_at :: !((Maybe Data.Time.UTCTime)), + team_members_team_id :: !(Data.Int.Int32), + team_members_login_id :: !(Data.Int.Int32), + team_members_role :: !((Pulse.Database.Types.Enum "team_role")), + team_members_created_at :: !((Maybe Data.Time.UTCTime)), + team_members_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeamMembers") where + toRow Params_getTeamMembers{..} = + [ + Database.PostgreSQL.Simple.ToField.toField team_members_team_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeamMembers") where + fromRow = + pure Result_getTeamMembers + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/GetTeams.hs b/test/golden/out/Pulse/Database/GetTeams.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/GetTeams.hs @@ -0,0 +1,60 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeams where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_getTeams :: Query "getTeams" ":many" +query_getTeams = Query "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at\nFROM teams\nWHERE organization_id = ? AND NOT is_deleted\nORDER BY display_name ASC" + +data instance Params "getTeams" = Params_getTeams + { + teams_organization_id :: Data.Int.Int32 + } + +data instance Result "getTeams" = Result_getTeams + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeams") where + toRow Params_getTeams{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeams") where + fromRow = + pure Result_getTeams + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertDefaultTeamIfNotExists.hs b/test/golden/out/Pulse/Database/InsertDefaultTeamIfNotExists.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertDefaultTeamIfNotExists.hs @@ -0,0 +1,66 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertDefaultTeamIfNotExists where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_insertDefaultTeamIfNotExists :: Query "insertDefaultTeamIfNotExists" ":one" +query_insertDefaultTeamIfNotExists = Query "INSERT INTO teams (\n organization_id, display_name, invitation_code, is_deleted\n) VALUES (?, ?, ?, false)\nON CONFLICT\n (organization_id, display_name)\n WHERE\n is_deleted = false\nDO UPDATE SET\n updated_at = NOW ()\nRETURNING id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at" + +data instance Params "insertDefaultTeamIfNotExists" = Params_insertDefaultTeamIfNotExists + { + teams_organization_id :: Data.Int.Int32, + teams_display_name :: Data.Text.Text, + teams_invitation_code :: Data.Text.Text + } + +data instance Result "insertDefaultTeamIfNotExists" = Result_insertDefaultTeamIfNotExists + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertDefaultTeamIfNotExists") where + toRow Params_insertDefaultTeamIfNotExists{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id, + + Database.PostgreSQL.Simple.ToField.toField teams_display_name, + + Database.PostgreSQL.Simple.ToField.toField teams_invitation_code + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertDefaultTeamIfNotExists") where + fromRow = + pure Result_insertDefaultTeamIfNotExists + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertEscalationNotification.hs b/test/golden/out/Pulse/Database/InsertEscalationNotification.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertEscalationNotification.hs @@ -0,0 +1,70 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertEscalationNotification where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_insertEscalationNotification :: Query "insertEscalationNotification" ":one" +query_insertEscalationNotification = Query "INSERT INTO escalation_notifications (\n incident_escalation_id, step_order, notification_channel, delivery_status\n) VALUES (?, ?, ?, ?) RETURNING id, incident_escalation_id, step_order, notification_channel, sent_at, delivery_status, error_message, created_at" + +data instance Params "insertEscalationNotification" = Params_insertEscalationNotification + { + escalation_notifications_incident_escalation_id :: Data.Int.Int64, + escalation_notifications_step_order :: Data.Int.Int32, + escalation_notifications_notification_channel :: Data.Text.Text, + escalation_notifications_delivery_status :: GHC.Base.Maybe Data.Text.Text + } + +data instance Result "insertEscalationNotification" = Result_insertEscalationNotification + { + escalation_notifications_id :: !(Data.Int.Int64), + escalation_notifications_incident_escalation_id :: !(Data.Int.Int64), + escalation_notifications_step_order :: !(Data.Int.Int32), + escalation_notifications_notification_channel :: !(Data.Text.Text), + escalation_notifications_sent_at :: !((Maybe Data.Time.UTCTime)), + escalation_notifications_delivery_status :: !(GHC.Base.Maybe Data.Text.Text), + escalation_notifications_error_message :: !(GHC.Base.Maybe Data.Text.Text), + escalation_notifications_created_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertEscalationNotification") where + toRow Params_insertEscalationNotification{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_notifications_incident_escalation_id, + + Database.PostgreSQL.Simple.ToField.toField escalation_notifications_step_order, + + Database.PostgreSQL.Simple.ToField.toField escalation_notifications_notification_channel, + + Database.PostgreSQL.Simple.ToField.toField escalation_notifications_delivery_status + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertEscalationNotification") where + fromRow = + pure Result_insertEscalationNotification + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertEscalationPolicy.hs b/test/golden/out/Pulse/Database/InsertEscalationPolicy.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertEscalationPolicy.hs @@ -0,0 +1,71 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertEscalationPolicy where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_insertEscalationPolicy :: Query "insertEscalationPolicy" ":one" +query_insertEscalationPolicy = Query "INSERT INTO escalation_policies (\n organization_id, name, description, is_default\n) VALUES (?, ?, ?, ?) RETURNING id, organization_id, name, description, is_default, is_deleted, created_at, updated_at" + +data instance Params "insertEscalationPolicy" = Params_insertEscalationPolicy + { + escalation_policies_organization_id :: Data.Int.Int32, + escalation_policies_name :: Data.Text.Text, + escalation_policies_description :: GHC.Base.Maybe Data.Text.Text, + escalation_policies_is_default :: GHC.Types.Bool + } + +data instance Result "insertEscalationPolicy" = Result_insertEscalationPolicy + { + escalation_policies_id :: !(Data.Int.Int32), + escalation_policies_organization_id :: !(Data.Int.Int32), + escalation_policies_name :: !(Data.Text.Text), + escalation_policies_description :: !(GHC.Base.Maybe Data.Text.Text), + escalation_policies_is_default :: !(GHC.Types.Bool), + escalation_policies_is_deleted :: !(GHC.Types.Bool), + escalation_policies_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_policies_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertEscalationPolicy") where + toRow Params_insertEscalationPolicy{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_policies_organization_id, + + Database.PostgreSQL.Simple.ToField.toField escalation_policies_name, + + Database.PostgreSQL.Simple.ToField.toField escalation_policies_description, + + Database.PostgreSQL.Simple.ToField.toField escalation_policies_is_default + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertEscalationPolicy") where + fromRow = + pure Result_insertEscalationPolicy + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertEscalationStep.hs b/test/golden/out/Pulse/Database/InsertEscalationStep.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertEscalationStep.hs @@ -0,0 +1,85 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertEscalationStep where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Time.LocalTime +import qualified GHC.Types +import qualified Data.Text +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_insertEscalationStep :: Query "insertEscalationStep" ":one" +query_insertEscalationStep = Query "INSERT INTO escalation_steps (\n escalation_policy_id, step_order, delay_interval,\n notify_by_email, notify_by_push, notify_by_critical_alert, message_template\n) VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING id, escalation_policy_id, step_order, delay_interval, notify_by_email, notify_by_push, notify_by_critical_alert, message_template, created_at, updated_at" + +data instance Params "insertEscalationStep" = Params_insertEscalationStep + { + escalation_steps_escalation_policy_id :: Data.Int.Int32, + escalation_steps_step_order :: Data.Int.Int32, + escalation_steps_delay_interval :: Data.Time.LocalTime.CalendarDiffTime, + escalation_steps_notify_by_email :: GHC.Types.Bool, + escalation_steps_notify_by_push :: GHC.Types.Bool, + escalation_steps_notify_by_critical_alert :: GHC.Types.Bool, + escalation_steps_message_template :: GHC.Base.Maybe Data.Text.Text + } + +data instance Result "insertEscalationStep" = Result_insertEscalationStep + { + escalation_steps_id :: !(Data.Int.Int32), + escalation_steps_escalation_policy_id :: !(Data.Int.Int32), + escalation_steps_step_order :: !(Data.Int.Int32), + escalation_steps_delay_interval :: !(Data.Time.LocalTime.CalendarDiffTime), + escalation_steps_notify_by_email :: !(GHC.Types.Bool), + escalation_steps_notify_by_push :: !(GHC.Types.Bool), + escalation_steps_notify_by_critical_alert :: !(GHC.Types.Bool), + escalation_steps_message_template :: !(GHC.Base.Maybe Data.Text.Text), + escalation_steps_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_steps_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertEscalationStep") where + toRow Params_insertEscalationStep{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_steps_escalation_policy_id, + + Database.PostgreSQL.Simple.ToField.toField escalation_steps_step_order, + + Database.PostgreSQL.Simple.ToField.toField escalation_steps_delay_interval, + + Database.PostgreSQL.Simple.ToField.toField escalation_steps_notify_by_email, + + Database.PostgreSQL.Simple.ToField.toField escalation_steps_notify_by_push, + + Database.PostgreSQL.Simple.ToField.toField escalation_steps_notify_by_critical_alert, + + Database.PostgreSQL.Simple.ToField.toField escalation_steps_message_template + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertEscalationStep") where + fromRow = + pure Result_insertEscalationStep + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertLogin.hs b/test/golden/out/Pulse/Database/InsertLogin.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertLogin.hs @@ -0,0 +1,56 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertLogin where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Text +import qualified GHC.Base +import qualified Pulse.Database.DBTypes +import qualified Data.Int +import qualified Data.Foldable + +query_insertLogin :: Query "insertLogin" ":one" +query_insertLogin = Query "INSERT INTO logins (\n display_name, login_email, password_bcrypt, timezone, is_deleted\n) VALUES (?, ?, ?, ?, false) RETURNING id" + +data instance Params "insertLogin" = Params_insertLogin + { + logins_display_name :: GHC.Base.Maybe Data.Text.Text, + logins_login_email :: Data.Text.Text, + logins_password_bcrypt :: Data.Text.Text, + logins_timezone :: Pulse.Database.DBTypes.Timezone + } + +data instance Result "insertLogin" = Result_insertLogin + { + logins_id :: !(Data.Int.Int32) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertLogin") where + toRow Params_insertLogin{..} = + [ + Database.PostgreSQL.Simple.ToField.toField logins_display_name, + + Database.PostgreSQL.Simple.ToField.toField logins_login_email, + + Database.PostgreSQL.Simple.ToField.toField logins_password_bcrypt, + + Database.PostgreSQL.Simple.ToField.toField logins_timezone + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertLogin") where + fromRow = + pure Result_insertLogin + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertNewMonitor.hs b/test/golden/out/Pulse/Database/InsertNewMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertNewMonitor.hs @@ -0,0 +1,87 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertNewMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_insertNewMonitor :: Query "insertNewMonitor" ":one" +query_insertNewMonitor = Query "INSERT INTO monitors\n (organization_id, name, type, healthiness, monitor_group, threshold_failures, escalation_policy_id, is_active, is_deleted)\nVALUES\n (?, ?, ?, 'unknown', ?, ?, ?, true, false)\nRETURNING id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id" + +data instance Params "insertNewMonitor" = Params_insertNewMonitor + { + monitors_organization_id :: Data.Int.Int32, + monitors_name :: Data.Text.Text, + monitors_type :: (Pulse.Database.Types.Enum "monitor_type"), + monitors_monitor_group :: Data.Text.Text, + monitors_threshold_failures :: Data.Int.Int32, + monitors_escalation_policy_id :: Data.Int.Int32 + } + +data instance Result "insertNewMonitor" = Result_insertNewMonitor + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertNewMonitor") where + toRow Params_insertNewMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_organization_id, + + Database.PostgreSQL.Simple.ToField.toField monitors_name, + + Database.PostgreSQL.Simple.ToField.toField monitors_type, + + Database.PostgreSQL.Simple.ToField.toField monitors_monitor_group, + + Database.PostgreSQL.Simple.ToField.toField monitors_threshold_failures, + + Database.PostgreSQL.Simple.ToField.toField monitors_escalation_policy_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertNewMonitor") where + fromRow = + pure Result_insertNewMonitor + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertNewOpcuaEndpointMonitor.hs b/test/golden/out/Pulse/Database/InsertNewOpcuaEndpointMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertNewOpcuaEndpointMonitor.hs @@ -0,0 +1,84 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertNewOpcuaEndpointMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_insertNewOpcuaEndpointMonitor :: Query "insertNewOpcuaEndpointMonitor" ":one" +query_insertNewOpcuaEndpointMonitor = Query "INSERT INTO opcua_endpoint_monitors\n (id, endpoint, mode, policy, certificate, credentials, incident_message_template)\nVALUES\n (?, ?, ?, ?, ?, ?, ?)\nRETURNING id, endpoint, mode, policy, certificate, credentials, incident_message_template, latest_connection_attempt, created_at, updated_at" + +data instance Params "insertNewOpcuaEndpointMonitor" = Params_insertNewOpcuaEndpointMonitor + { + opcua_endpoint_monitors_id :: Data.Int.Int32, + opcua_endpoint_monitors_endpoint :: Data.Text.Text, + opcua_endpoint_monitors_mode :: (Pulse.Database.Types.Enum "opcua_security_mode"), + opcua_endpoint_monitors_policy :: (Pulse.Database.Types.Enum "opcua_security_policy"), + opcua_endpoint_monitors_certificate :: GHC.Base.Maybe Data.Int.Int32, + opcua_endpoint_monitors_credentials :: GHC.Base.Maybe Data.Int.Int32, + opcua_endpoint_monitors_incident_message_template :: GHC.Base.Maybe Data.Text.Text + } + +data instance Result "insertNewOpcuaEndpointMonitor" = Result_insertNewOpcuaEndpointMonitor + { + opcua_endpoint_monitors_id :: !(Data.Int.Int32), + opcua_endpoint_monitors_endpoint :: !(Data.Text.Text), + opcua_endpoint_monitors_mode :: !((Pulse.Database.Types.Enum "opcua_security_mode")), + opcua_endpoint_monitors_policy :: !((Pulse.Database.Types.Enum "opcua_security_policy")), + opcua_endpoint_monitors_certificate :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_credentials :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_monitors_latest_connection_attempt :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertNewOpcuaEndpointMonitor") where + toRow Params_insertNewOpcuaEndpointMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_endpoint, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_mode, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_policy, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_certificate, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_credentials, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_incident_message_template + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertNewOpcuaEndpointMonitor") where + fromRow = + pure Result_insertNewOpcuaEndpointMonitor + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertOpcuaAttributeValue.hs b/test/golden/out/Pulse/Database/InsertOpcuaAttributeValue.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertOpcuaAttributeValue.hs @@ -0,0 +1,73 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertOpcuaAttributeValue where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Pulse.Database.DBTypes +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Text +import qualified Data.Foldable + +query_insertOpcuaAttributeValue :: Query "insertOpcuaAttributeValue" ":exec" +query_insertOpcuaAttributeValue = Query "INSERT INTO opcua_attribute_values\n( endpoint_monitor_id,\n attribute_id,\n opcua_node_id,\n value_type,\n value_integral,\n value_float,\n value_bool,\n value_string,\n value_status_code,\n value\n)\nVALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" + +data instance Params "insertOpcuaAttributeValue" = Params_insertOpcuaAttributeValue + { + opcua_attribute_values_endpoint_monitor_id :: Data.Int.Int32, + opcua_attribute_values_attribute_id :: Pulse.Database.DBTypes.OpcuaAttributeId, + opcua_attribute_values_opcua_node_id :: Pulse.Database.DBTypes.OpcuaNodeId, + opcua_attribute_values_value_type :: Pulse.Database.DBTypes.OpcuaDataValueType, + opcua_attribute_values_value_integral :: GHC.Base.Maybe Data.Int.Int64, + opcua_attribute_values_value_float :: GHC.Base.Maybe GHC.Types.Double, + opcua_attribute_values_value_bool :: GHC.Base.Maybe GHC.Types.Bool, + opcua_attribute_values_value_string :: GHC.Base.Maybe Data.Text.Text, + opcua_attribute_values_value_status_code :: GHC.Base.Maybe Data.Int.Int32, + opcua_attribute_values_value :: Pulse.Database.DBTypes.OpcuaDataValue + } + +data instance Result "insertOpcuaAttributeValue" = Result_insertOpcuaAttributeValue + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertOpcuaAttributeValue") where + toRow Params_insertOpcuaAttributeValue{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_endpoint_monitor_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_attribute_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_opcua_node_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_value_type, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_value_integral, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_value_float, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_value_bool, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_value_string, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_value_status_code, + + Database.PostgreSQL.Simple.ToField.toField opcua_attribute_values_value + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertOpcuaAttributeValue") where + fromRow = + pure Result_insertOpcuaAttributeValue + + diff --git a/test/golden/out/Pulse/Database/InsertOpcuaEndpointCertificate.hs b/test/golden/out/Pulse/Database/InsertOpcuaEndpointCertificate.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertOpcuaEndpointCertificate.hs @@ -0,0 +1,95 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertOpcuaEndpointCertificate where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Pulse.Database.Types +import qualified Data.Text +import qualified Data.Time +import qualified Data.ByteString +import qualified Database.PostgreSQL.Simple +import qualified Data.Foldable + +query_insertOpcuaEndpointCertificate :: Query "insertOpcuaEndpointCertificate" ":one" +query_insertOpcuaEndpointCertificate = Query "INSERT INTO opcua_endpoint_certificates\n (organization_id, provided_by, subject, issuer, signature, valid_from, valid_to, certificate, private_key)\nVALUES\n (?, ?, ?, ?, ?, ?, ?, ?, ?)\nON CONFLICT\n (organization_id, signature)\nDO UPDATE SET\n updated_at = NOW ()\nRETURNING id, organization_id, provided_by, subject, issuer, signature, valid_from, valid_to, certificate, private_key, created_at, updated_at" + +data instance Params "insertOpcuaEndpointCertificate" = Params_insertOpcuaEndpointCertificate + { + opcua_endpoint_certificates_organization_id :: Data.Int.Int32, + opcua_endpoint_certificates_provided_by :: (Pulse.Database.Types.Enum "certificate_provider"), + opcua_endpoint_certificates_subject :: Data.Text.Text, + opcua_endpoint_certificates_issuer :: Data.Text.Text, + opcua_endpoint_certificates_signature :: Data.Text.Text, + opcua_endpoint_certificates_valid_from :: Data.Time.UTCTime, + opcua_endpoint_certificates_valid_to :: Data.Time.UTCTime, + opcua_endpoint_certificates_certificate :: (Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString), + opcua_endpoint_certificates_private_key :: (Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString) + } + +data instance Result "insertOpcuaEndpointCertificate" = Result_insertOpcuaEndpointCertificate + { + opcua_endpoint_certificates_id :: !(Data.Int.Int32), + opcua_endpoint_certificates_organization_id :: !(Data.Int.Int32), + opcua_endpoint_certificates_provided_by :: !((Pulse.Database.Types.Enum "certificate_provider")), + opcua_endpoint_certificates_subject :: !(Data.Text.Text), + opcua_endpoint_certificates_issuer :: !(Data.Text.Text), + opcua_endpoint_certificates_signature :: !(Data.Text.Text), + opcua_endpoint_certificates_valid_from :: !(Data.Time.UTCTime), + opcua_endpoint_certificates_valid_to :: !(Data.Time.UTCTime), + opcua_endpoint_certificates_certificate :: !((Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString)), + opcua_endpoint_certificates_private_key :: !((Database.PostgreSQL.Simple.Binary Data.ByteString.ByteString)), + opcua_endpoint_certificates_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_certificates_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertOpcuaEndpointCertificate") where + toRow Params_insertOpcuaEndpointCertificate{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_organization_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_provided_by, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_subject, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_issuer, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_signature, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_valid_from, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_valid_to, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_certificate, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_certificates_private_key + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertOpcuaEndpointCertificate") where + fromRow = + pure Result_insertOpcuaEndpointCertificate + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertOpcuaEndpointCredentials.hs b/test/golden/out/Pulse/Database/InsertOpcuaEndpointCredentials.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertOpcuaEndpointCredentials.hs @@ -0,0 +1,67 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertOpcuaEndpointCredentials where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Data.Time +import qualified Data.Foldable + +query_insertOpcuaEndpointCredentials :: Query "insertOpcuaEndpointCredentials" ":one" +query_insertOpcuaEndpointCredentials = Query "INSERT INTO opcua_endpoint_credentials\n (organization_id, name, username, password)\nVALUES\n (?, ?, ?, ?)\nON CONFLICT\n (organization_id, name)\nDO UPDATE SET\n updated_at = NOW ()\nRETURNING id, organization_id, name, username, password, created_at, updated_at" + +data instance Params "insertOpcuaEndpointCredentials" = Params_insertOpcuaEndpointCredentials + { + opcua_endpoint_credentials_organization_id :: Data.Int.Int32, + opcua_endpoint_credentials_name :: Data.Text.Text, + opcua_endpoint_credentials_username :: Data.Text.Text, + opcua_endpoint_credentials_password :: Data.Text.Text + } + +data instance Result "insertOpcuaEndpointCredentials" = Result_insertOpcuaEndpointCredentials + { + opcua_endpoint_credentials_id :: !(Data.Int.Int32), + opcua_endpoint_credentials_organization_id :: !(Data.Int.Int32), + opcua_endpoint_credentials_name :: !(Data.Text.Text), + opcua_endpoint_credentials_username :: !(Data.Text.Text), + opcua_endpoint_credentials_password :: !(Data.Text.Text), + opcua_endpoint_credentials_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_credentials_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertOpcuaEndpointCredentials") where + toRow Params_insertOpcuaEndpointCredentials{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_credentials_organization_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_credentials_name, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_credentials_username, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_credentials_password + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertOpcuaEndpointCredentials") where + fromRow = + pure Result_insertOpcuaEndpointCredentials + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertOpcuaNodeMonitor.hs b/test/golden/out/Pulse/Database/InsertOpcuaNodeMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertOpcuaNodeMonitor.hs @@ -0,0 +1,94 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertOpcuaNodeMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Pulse.Database.DBTypes +import qualified Pulse.Database.Types +import qualified Data.Text +import qualified Data.Time.LocalTime +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_insertOpcuaNodeMonitor :: Query "insertOpcuaNodeMonitor" ":one" +query_insertOpcuaNodeMonitor = Query "INSERT INTO opcua_node_monitors\n (id, endpoint_monitor_id, opcua_node_id, aggregation, operand, operation, duration, frequency, incident_message_template)\nVALUES\n (?, ?, ?, ?, ?, ?, ?, ?, ?)\nRETURNING id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, created_at, updated_at" + +data instance Params "insertOpcuaNodeMonitor" = Params_insertOpcuaNodeMonitor + { + opcua_node_monitors_id :: Data.Int.Int32, + opcua_node_monitors_endpoint_monitor_id :: Data.Int.Int32, + opcua_node_monitors_opcua_node_id :: Pulse.Database.DBTypes.OpcuaNodeId, + opcua_node_monitors_aggregation :: (Pulse.Database.Types.Enum "check_aggregation"), + opcua_node_monitors_operand :: Data.Text.Text, + opcua_node_monitors_operation :: (Pulse.Database.Types.Enum "check_op"), + opcua_node_monitors_duration :: Data.Time.LocalTime.CalendarDiffTime, + opcua_node_monitors_frequency :: Data.Time.LocalTime.CalendarDiffTime, + opcua_node_monitors_incident_message_template :: GHC.Base.Maybe Data.Text.Text + } + +data instance Result "insertOpcuaNodeMonitor" = Result_insertOpcuaNodeMonitor + { + opcua_node_monitors_id :: !(Data.Int.Int32), + opcua_node_monitors_endpoint_monitor_id :: !(Data.Int.Int32), + opcua_node_monitors_opcua_node_id :: !(Pulse.Database.DBTypes.OpcuaNodeId), + opcua_node_monitors_aggregation :: !((Pulse.Database.Types.Enum "check_aggregation")), + opcua_node_monitors_operation :: !((Pulse.Database.Types.Enum "check_op")), + opcua_node_monitors_operand :: !(Data.Text.Text), + opcua_node_monitors_duration :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_frequency :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_node_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_node_monitors_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertOpcuaNodeMonitor") where + toRow Params_insertOpcuaNodeMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_endpoint_monitor_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_opcua_node_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_aggregation, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_operand, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_operation, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_duration, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_frequency, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_incident_message_template + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertOpcuaNodeMonitor") where + fromRow = + pure Result_insertOpcuaNodeMonitor + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertOrganizationLogin.hs b/test/golden/out/Pulse/Database/InsertOrganizationLogin.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertOrganizationLogin.hs @@ -0,0 +1,60 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertOrganizationLogin where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Pulse.Database.Types +import qualified Data.Time +import qualified Data.Foldable + +query_insertOrganizationLogin :: Query "insertOrganizationLogin" ":one" +query_insertOrganizationLogin = Query "INSERT INTO organization_logins (login_id, organization_id, role) VALUES (\n ?, ?, ?\n) ON CONFLICT (login_id, organization_id) DO NOTHING RETURNING login_id, organization_id, role, created_at, updated_at" + +data instance Params "insertOrganizationLogin" = Params_insertOrganizationLogin + { + organization_logins_login_id :: Data.Int.Int32, + organization_logins_organization_id :: Data.Int.Int32, + organization_logins_role :: (Pulse.Database.Types.Enum "organization_role") + } + +data instance Result "insertOrganizationLogin" = Result_insertOrganizationLogin + { + organization_logins_login_id :: !(Data.Int.Int32), + organization_logins_organization_id :: !(Data.Int.Int32), + organization_logins_role :: !((Pulse.Database.Types.Enum "organization_role")), + organization_logins_created_at :: !((Maybe Data.Time.UTCTime)), + organization_logins_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertOrganizationLogin") where + toRow Params_insertOrganizationLogin{..} = + [ + Database.PostgreSQL.Simple.ToField.toField organization_logins_login_id, + + Database.PostgreSQL.Simple.ToField.toField organization_logins_organization_id, + + Database.PostgreSQL.Simple.ToField.toField organization_logins_role + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertOrganizationLogin") where + fromRow = + pure Result_insertOrganizationLogin + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertSeverity.hs b/test/golden/out/Pulse/Database/InsertSeverity.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertSeverity.hs @@ -0,0 +1,73 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertSeverity where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_insertSeverity :: Query "insertSeverity" ":one" +query_insertSeverity = Query "INSERT INTO severities (\n team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert\n) VALUES (?, ?, ?, ?, ?) RETURNING id, team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert, created_at, updated_at" + +data instance Params "insertSeverity" = Params_insertSeverity + { + severities_team_id :: Data.Int.Int32, + severities_name :: Data.Text.Text, + severities_notify_by_email :: GHC.Types.Bool, + severities_notify_by_push :: GHC.Types.Bool, + severities_notify_by_critical_alert :: GHC.Types.Bool + } + +data instance Result "insertSeverity" = Result_insertSeverity + { + severities_id :: !(Data.Int.Int32), + severities_team_id :: !(Data.Int.Int32), + severities_name :: !(Data.Text.Text), + severities_notify_by_email :: !(GHC.Types.Bool), + severities_notify_by_push :: !(GHC.Types.Bool), + severities_notify_by_critical_alert :: !(GHC.Types.Bool), + severities_created_at :: !((Maybe Data.Time.UTCTime)), + severities_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertSeverity") where + toRow Params_insertSeverity{..} = + [ + Database.PostgreSQL.Simple.ToField.toField severities_team_id, + + Database.PostgreSQL.Simple.ToField.toField severities_name, + + Database.PostgreSQL.Simple.ToField.toField severities_notify_by_email, + + Database.PostgreSQL.Simple.ToField.toField severities_notify_by_push, + + Database.PostgreSQL.Simple.ToField.toField severities_notify_by_critical_alert + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertSeverity") where + fromRow = + pure Result_insertSeverity + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertTeam.hs b/test/golden/out/Pulse/Database/InsertTeam.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertTeam.hs @@ -0,0 +1,66 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertTeam where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_insertTeam :: Query "insertTeam" ":one" +query_insertTeam = Query "INSERT INTO teams (\n organization_id, display_name, invitation_code, is_deleted\n) VALUES (?, ?, ?, false) RETURNING id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at" + +data instance Params "insertTeam" = Params_insertTeam + { + teams_organization_id :: Data.Int.Int32, + teams_display_name :: Data.Text.Text, + teams_invitation_code :: Data.Text.Text + } + +data instance Result "insertTeam" = Result_insertTeam + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertTeam") where + toRow Params_insertTeam{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id, + + Database.PostgreSQL.Simple.ToField.toField teams_display_name, + + Database.PostgreSQL.Simple.ToField.toField teams_invitation_code + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertTeam") where + fromRow = + pure Result_insertTeam + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/InsertTeamMember.hs b/test/golden/out/Pulse/Database/InsertTeamMember.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/InsertTeamMember.hs @@ -0,0 +1,49 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertTeamMember where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Pulse.Database.Types +import qualified Data.Foldable + +query_insertTeamMember :: Query "insertTeamMember" ":exec" +query_insertTeamMember = Query "INSERT INTO team_members (team_id, login_id, role) VALUES (\n ?, ?, ?\n) ON CONFLICT (team_id, login_id) DO NOTHING" + +data instance Params "insertTeamMember" = Params_insertTeamMember + { + team_members_team_id :: Data.Int.Int32, + team_members_login_id :: Data.Int.Int32, + team_members_role :: (Pulse.Database.Types.Enum "team_role") + } + +data instance Result "insertTeamMember" = Result_insertTeamMember + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertTeamMember") where + toRow Params_insertTeamMember{..} = + [ + Database.PostgreSQL.Simple.ToField.toField team_members_team_id, + + Database.PostgreSQL.Simple.ToField.toField team_members_login_id, + + Database.PostgreSQL.Simple.ToField.toField team_members_role + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertTeamMember") where + fromRow = + pure Result_insertTeamMember + + diff --git a/test/golden/out/Pulse/Database/Internal.hs b/test/golden/out/Pulse/Database/Internal.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/Internal.hs @@ -0,0 +1,132 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.Internal ( + Query(..), + Params, + Result, + Pulse.Database.Internal.Enum, + + -- * :execResult + ExecResult(..), + execResult, + + -- * :exec + exec, + + -- * :execrows + execRows, + + -- * :one + queryOne, + + -- * :many + queryMany, + fold, + + -- * :copyfrom + execMany, + + -- * Reexports + Database.PostgreSQL.Simple.Connection, + Database.PostgreSQL.Simple.ToRow, + Database.PostgreSQL.Simple.FromRow, + ) where + +import Data.Foldable (Foldable) +import qualified Data.Foldable +import Data.Vector (Vector) +import Database.PostgreSQL.Simple (Connection, FromRow, ToRow) +import GHC.TypeLits (Symbol) +import qualified Data.ByteString.Char8 +import qualified Data.Int +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.Types +import qualified Database.PostgreSQL.Simple.Vector + +newtype Query (name :: Symbol) (command :: Symbol) + = Query Database.PostgreSQL.Simple.Query + +data family Params (name :: Symbol) + +data family Result (name :: Symbol) + +data family Enum (name :: Symbol) + +data ExecResult = ExecResult + { rowsAffected :: !Data.Int.Int64 + } + +exec :: + (ToRow (Params name)) => + Connection -> + Query name ":exec" -> + Params name -> + IO () +exec connection (Query sql) params = do + _rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure () + +execRows :: + (ToRow (Params name)) => + Connection -> + Query name ":execrows" -> + Params name -> + IO Data.Int.Int64 +execRows connection (Query sql) params = do + Database.PostgreSQL.Simple.execute connection sql params + +execResult :: + (ToRow (Params name)) => + Connection -> + Query name ":execresult" -> + Params name -> + IO ExecResult +execResult connection (Query sql) params = do + rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure ExecResult { + rowsAffected + } + +queryOne :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":one" -> + Params name -> + IO (Maybe (Result name)) +queryOne connection (Query sql) params = do + result <- Database.PostgreSQL.Simple.query connection sql params + case result of + [] -> pure Nothing + x : _ -> pure (Just x) + +queryMany :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + IO (Vector (Result name)) +queryMany connection (Query sql) params = + Database.PostgreSQL.Simple.Vector.query connection sql params + +execMany :: + (ToRow (Params name), FromRow (Result name), Foldable f) => + Connection -> + Query name ":copyfrom" -> + f (Params name) -> + IO Data.Int.Int64 +execMany connection (Query sql) params = + Database.PostgreSQL.Simple.executeMany connection sql (Data.Foldable.toList params) + +fold :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + a -> + (a -> Result name -> IO a) -> + IO a +fold connection (Query sql) params = do + Database.PostgreSQL.Simple.fold connection sql params +{-# INLINABLE fold #-} diff --git a/test/golden/out/Pulse/Database/MarkAcknowledgedNotificationSent.hs b/test/golden/out/Pulse/Database/MarkAcknowledgedNotificationSent.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/MarkAcknowledgedNotificationSent.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.MarkAcknowledgedNotificationSent where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_markAcknowledgedNotificationSent :: Query "markAcknowledgedNotificationSent" ":exec" +query_markAcknowledgedNotificationSent = Query "UPDATE incident_escalations\nSET acknowledged_notification_sent_at = NOW(), updated_at = NOW()\nWHERE id = ?" + +data instance Params "markAcknowledgedNotificationSent" = Params_markAcknowledgedNotificationSent + { + incident_escalations_id :: Data.Int.Int64 + } + +data instance Result "markAcknowledgedNotificationSent" = Result_markAcknowledgedNotificationSent + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "markAcknowledgedNotificationSent") where + toRow Params_markAcknowledgedNotificationSent{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incident_escalations_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "markAcknowledgedNotificationSent") where + fromRow = + pure Result_markAcknowledgedNotificationSent + + diff --git a/test/golden/out/Pulse/Database/MarkIncidentNotificationSent.hs b/test/golden/out/Pulse/Database/MarkIncidentNotificationSent.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/MarkIncidentNotificationSent.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.MarkIncidentNotificationSent where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_markIncidentNotificationSent :: Query "markIncidentNotificationSent" ":exec" +query_markIncidentNotificationSent = Query "UPDATE incident_escalations\nSET incident_notification_sent_at = NOW(), updated_at = NOW()\nWHERE id = ?" + +data instance Params "markIncidentNotificationSent" = Params_markIncidentNotificationSent + { + incident_escalations_id :: Data.Int.Int64 + } + +data instance Result "markIncidentNotificationSent" = Result_markIncidentNotificationSent + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "markIncidentNotificationSent") where + toRow Params_markIncidentNotificationSent{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incident_escalations_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "markIncidentNotificationSent") where + fromRow = + pure Result_markIncidentNotificationSent + + diff --git a/test/golden/out/Pulse/Database/MarkResolvedNotificationSent.hs b/test/golden/out/Pulse/Database/MarkResolvedNotificationSent.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/MarkResolvedNotificationSent.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.MarkResolvedNotificationSent where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_markResolvedNotificationSent :: Query "markResolvedNotificationSent" ":exec" +query_markResolvedNotificationSent = Query "UPDATE incident_escalations\nSET resolved_notification_sent_at = NOW(), updated_at = NOW()\nWHERE id = ?" + +data instance Params "markResolvedNotificationSent" = Params_markResolvedNotificationSent + { + incident_escalations_id :: Data.Int.Int64 + } + +data instance Result "markResolvedNotificationSent" = Result_markResolvedNotificationSent + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "markResolvedNotificationSent") where + toRow Params_markResolvedNotificationSent{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incident_escalations_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "markResolvedNotificationSent") where + fromRow = + pure Result_markResolvedNotificationSent + + diff --git a/test/golden/out/Pulse/Database/PauseIncidentEscalation.hs b/test/golden/out/Pulse/Database/PauseIncidentEscalation.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/PauseIncidentEscalation.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.PauseIncidentEscalation where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_pauseIncidentEscalation :: Query "pauseIncidentEscalation" ":exec" +query_pauseIncidentEscalation = Query "UPDATE incident_escalations\nSET is_active = FALSE, updated_at = NOW()\nWHERE id = ?" + +data instance Params "pauseIncidentEscalation" = Params_pauseIncidentEscalation + { + incident_escalations_id :: Data.Int.Int64 + } + +data instance Result "pauseIncidentEscalation" = Result_pauseIncidentEscalation + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "pauseIncidentEscalation") where + toRow Params_pauseIncidentEscalation{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incident_escalations_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "pauseIncidentEscalation") where + fromRow = + pure Result_pauseIncidentEscalation + + diff --git a/test/golden/out/Pulse/Database/PauseMonitor.hs b/test/golden/out/Pulse/Database/PauseMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/PauseMonitor.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.PauseMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_pauseMonitor :: Query "pauseMonitor" ":exec" +query_pauseMonitor = Query "UPDATE\n monitors\nSET\n is_active = false,\n updated_at = NOW()\nWHERE\n monitors.id = ?" + +data instance Params "pauseMonitor" = Params_pauseMonitor + { + monitors_id :: Data.Int.Int32 + } + +data instance Result "pauseMonitor" = Result_pauseMonitor + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "pauseMonitor") where + toRow Params_pauseMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "pauseMonitor") where + fromRow = + pure Result_pauseMonitor + + diff --git a/test/golden/out/Pulse/Database/ResolveIncidentsByFailingMonitors.hs b/test/golden/out/Pulse/Database/ResolveIncidentsByFailingMonitors.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/ResolveIncidentsByFailingMonitors.hs @@ -0,0 +1,64 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.ResolveIncidentsByFailingMonitors where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified GHC.Base +import qualified Pulse.Database.Types +import qualified Data.Time +import qualified Data.Foldable + +query_resolveIncidentsByFailingMonitors :: Query "resolveIncidentsByFailingMonitors" ":many" +query_resolveIncidentsByFailingMonitors = Query "WITH resolved_incidents AS (\n UPDATE\n incidents\n SET\n status = 'resolved',\n updated_at = NOW()\n WHERE\n incidents.organization_id = ?\n AND incidents.status <> 'resolved'\n AND incidents.failing_monitor IN ?\n RETURNING id, organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, created_at, updated_at\n),\nrecovered_monitor_event AS (\n INSERT INTO\n incident_events (incident_id, type, failing_monitor)\n SELECT\n resolved_incidents.id, 'monitor_recovered', resolved_incidents.failing_monitor\n FROM\n resolved_incidents\n)\nINSERT INTO\n incident_events (incident_id, type)\nSELECT\n resolved_incidents.id, 'incident_resolved'\nFROM\n resolved_incidents\nRETURNING id, incident_id, type, failing_monitor, notification_recipients, acknowledged_by, resolved_by, created_at" + +data instance Params "resolveIncidentsByFailingMonitors" = Params_resolveIncidentsByFailingMonitors + { + incidents_organization_id :: Data.Int.Int32, + incidents_failing_monitors :: GHC.Base.Maybe [Data.Int.Int32] + } + +data instance Result "resolveIncidentsByFailingMonitors" = Result_resolveIncidentsByFailingMonitors + { + incident_events_id :: !(Data.Int.Int64), + incident_events_incident_id :: !(Data.Int.Int64), + incident_events_type :: !((Pulse.Database.Types.Enum "event_type")), + incident_events_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incident_events_notification_recipients :: !(GHC.Base.Maybe Data.Int.Int32), + incident_events_acknowledged_by :: !(GHC.Base.Maybe Data.Int.Int32), + incident_events_resolved_by :: !(GHC.Base.Maybe Data.Int.Int32), + incident_events_created_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "resolveIncidentsByFailingMonitors") where + toRow Params_resolveIncidentsByFailingMonitors{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incidents_organization_id, + + Database.PostgreSQL.Simple.ToField.toField (fmap (Database.PostgreSQL.Simple.In . Data.Foldable.toList) incidents_failing_monitors) + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "resolveIncidentsByFailingMonitors") where + fromRow = + pure Result_resolveIncidentsByFailingMonitors + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/ResumeIncidentEscalation.hs b/test/golden/out/Pulse/Database/ResumeIncidentEscalation.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/ResumeIncidentEscalation.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.ResumeIncidentEscalation where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_resumeIncidentEscalation :: Query "resumeIncidentEscalation" ":exec" +query_resumeIncidentEscalation = Query "UPDATE incident_escalations\nSET is_active = TRUE, updated_at = NOW()\nWHERE id = ?" + +data instance Params "resumeIncidentEscalation" = Params_resumeIncidentEscalation + { + incident_escalations_id :: Data.Int.Int64 + } + +data instance Result "resumeIncidentEscalation" = Result_resumeIncidentEscalation + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "resumeIncidentEscalation") where + toRow Params_resumeIncidentEscalation{..} = + [ + Database.PostgreSQL.Simple.ToField.toField incident_escalations_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "resumeIncidentEscalation") where + fromRow = + pure Result_resumeIncidentEscalation + + diff --git a/test/golden/out/Pulse/Database/SetIncidentToAcknowledged.hs b/test/golden/out/Pulse/Database/SetIncidentToAcknowledged.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/SetIncidentToAcknowledged.hs @@ -0,0 +1,68 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.SetIncidentToAcknowledged where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified Pulse.Database.Types +import qualified Data.Time +import qualified Data.Foldable + +query_setIncidentToAcknowledged :: Query "setIncidentToAcknowledged" ":one" +query_setIncidentToAcknowledged = Query "UPDATE\n incidents\nSET\n status = 'acknowledged',\n updated_at = NOW()\nWHERE\n incidents.id IN ?\n AND incidents.status = 'unacknowledged'\nRETURNING id, organization_id, display_name, description, failing_monitor, status, lead_by, acknowledged_by, unacknowledged_at, created_at, updated_at" + +data instance Params "setIncidentToAcknowledged" = Params_setIncidentToAcknowledged + { + incidents_incidents_ids :: [Data.Int.Int64] + } + +data instance Result "setIncidentToAcknowledged" = Result_setIncidentToAcknowledged + { + incidents_id :: !(Data.Int.Int64), + incidents_organization_id :: !(Data.Int.Int32), + incidents_display_name :: !(Data.Text.Text), + incidents_description :: !(GHC.Base.Maybe Data.Text.Text), + incidents_failing_monitor :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_status :: !((Pulse.Database.Types.Enum "incident_status")), + incidents_lead_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_acknowledged_by :: !(GHC.Base.Maybe Data.Int.Int32), + incidents_unacknowledged_at :: !((Maybe Data.Time.UTCTime)), + incidents_created_at :: !((Maybe Data.Time.UTCTime)), + incidents_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "setIncidentToAcknowledged") where + toRow Params_setIncidentToAcknowledged{..} = + [ + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList incidents_incidents_ids)) + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "setIncidentToAcknowledged") where + fromRow = + pure Result_setIncidentToAcknowledged + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/TickleHeartbeatMonitor.hs b/test/golden/out/Pulse/Database/TickleHeartbeatMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/TickleHeartbeatMonitor.hs @@ -0,0 +1,83 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.TickleHeartbeatMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Text +import qualified Data.Int +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Time.LocalTime +import qualified Data.Foldable + +query_tickleHeartbeatMonitor :: Query "tickleHeartbeatMonitor" ":one" +query_tickleHeartbeatMonitor = Query "UPDATE heartbeat_monitors SET last_heartbeat = NOW()\nFROM monitors\nWHERE\n monitors.id = heartbeat_monitors.id\n AND NOT monitors.is_deleted\n AND heartbeat_slug = ?\nRETURNING monitors.id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, monitors.created_at, updated_at, escalation_policy_id, heartbeat_monitors.id, heartbeat_slug, last_heartbeat, expected_interval, heartbeat_monitors.created_at" + +data instance Params "tickleHeartbeatMonitor" = Params_tickleHeartbeatMonitor + { + heartbeat_monitors_heartbeat_slug :: Data.Text.Text + } + +data instance Result "tickleHeartbeatMonitor" = Result_tickleHeartbeatMonitor + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32), + heartbeat_monitors_id :: !(Data.Int.Int32), + heartbeat_monitors_heartbeat_slug :: !(Data.Text.Text), + heartbeat_monitors_last_heartbeat :: !((Maybe Data.Time.UTCTime)), + heartbeat_monitors_expected_interval :: !(Data.Time.LocalTime.CalendarDiffTime), + heartbeat_monitors_created_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "tickleHeartbeatMonitor") where + toRow Params_tickleHeartbeatMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField heartbeat_monitors_heartbeat_slug + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "tickleHeartbeatMonitor") where + fromRow = + pure Result_tickleHeartbeatMonitor + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/Types.hs b/test/golden/out/Pulse/Database/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/Types.hs @@ -0,0 +1,308 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.Types where + +import qualified Control.Monad +import qualified Data.Text +import qualified Database.PostgreSQL.Simple.FromField +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow +import Pulse.Database.Internal +import Prelude hiding (Enum) +import qualified Prelude + +data instance Enum "organization_role" + = Enum_organization_role_owner + | Enum_organization_role_admin + | Enum_organization_role_member + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "organization_role") where + toField Enum_organization_role_owner = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "owner" + toField Enum_organization_role_admin = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "admin" + toField Enum_organization_role_member = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "member" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "organization_role") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "organization_role") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "owner" -> pure Enum_organization_role_owner + Just "admin" -> pure Enum_organization_role_admin + Just "member" -> pure Enum_organization_role_member + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "team_role" + = Enum_team_role_admin + | Enum_team_role_member + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "team_role") where + toField Enum_team_role_admin = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "admin" + toField Enum_team_role_member = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "member" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "team_role") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "team_role") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "admin" -> pure Enum_team_role_admin + Just "member" -> pure Enum_team_role_member + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "monitor_type" + = Enum_monitor_type_heartbeat + | Enum_monitor_type_opcua_endpoint + | Enum_monitor_type_opcua_node + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "monitor_type") where + toField Enum_monitor_type_heartbeat = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "heartbeat" + toField Enum_monitor_type_opcua_endpoint = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "opcua_endpoint" + toField Enum_monitor_type_opcua_node = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "opcua_node" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "monitor_type") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "monitor_type") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "heartbeat" -> pure Enum_monitor_type_heartbeat + Just "opcua_endpoint" -> pure Enum_monitor_type_opcua_endpoint + Just "opcua_node" -> pure Enum_monitor_type_opcua_node + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "monitor_healthiness" + = Enum_monitor_healthiness_unknown + | Enum_monitor_healthiness_healthy + | Enum_monitor_healthiness_suspicious + | Enum_monitor_healthiness_unhealthy + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "monitor_healthiness") where + toField Enum_monitor_healthiness_unknown = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "unknown" + toField Enum_monitor_healthiness_healthy = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "healthy" + toField Enum_monitor_healthiness_suspicious = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "suspicious" + toField Enum_monitor_healthiness_unhealthy = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "unhealthy" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "monitor_healthiness") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "monitor_healthiness") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "unknown" -> pure Enum_monitor_healthiness_unknown + Just "healthy" -> pure Enum_monitor_healthiness_healthy + Just "suspicious" -> pure Enum_monitor_healthiness_suspicious + Just "unhealthy" -> pure Enum_monitor_healthiness_unhealthy + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "opcua_security_mode" + = Enum_opcua_security_mode_None + | Enum_opcua_security_mode_Sign + | Enum_opcua_security_mode_SignAndEncrypt + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "opcua_security_mode") where + toField Enum_opcua_security_mode_None = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "None" + toField Enum_opcua_security_mode_Sign = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "Sign" + toField Enum_opcua_security_mode_SignAndEncrypt = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "SignAndEncrypt" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "opcua_security_mode") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "opcua_security_mode") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "None" -> pure Enum_opcua_security_mode_None + Just "Sign" -> pure Enum_opcua_security_mode_Sign + Just "SignAndEncrypt" -> pure Enum_opcua_security_mode_SignAndEncrypt + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "opcua_security_policy" + = Enum_opcua_security_policy_None + | Enum_opcua_security_policy_Basic128Rsa15 + | Enum_opcua_security_policy_Basic256 + | Enum_opcua_security_policy_Basic256Sha256 + | Enum_opcua_security_policy_Aes128Sha256RsaOaep + | Enum_opcua_security_policy_Aes256Sha256RsaPss + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "opcua_security_policy") where + toField Enum_opcua_security_policy_None = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "None" + toField Enum_opcua_security_policy_Basic128Rsa15 = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "Basic128Rsa15" + toField Enum_opcua_security_policy_Basic256 = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "Basic256" + toField Enum_opcua_security_policy_Basic256Sha256 = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "Basic256Sha256" + toField Enum_opcua_security_policy_Aes128Sha256RsaOaep = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "Aes128Sha256RsaOaep" + toField Enum_opcua_security_policy_Aes256Sha256RsaPss = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "Aes256Sha256RsaPss" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "opcua_security_policy") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "opcua_security_policy") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "None" -> pure Enum_opcua_security_policy_None + Just "Basic128Rsa15" -> pure Enum_opcua_security_policy_Basic128Rsa15 + Just "Basic256" -> pure Enum_opcua_security_policy_Basic256 + Just "Basic256Sha256" -> pure Enum_opcua_security_policy_Basic256Sha256 + Just "Aes128Sha256RsaOaep" -> pure Enum_opcua_security_policy_Aes128Sha256RsaOaep + Just "Aes256Sha256RsaPss" -> pure Enum_opcua_security_policy_Aes256Sha256RsaPss + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "certificate_provider" + = Enum_certificate_provider_pulse + | Enum_certificate_provider_customer + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "certificate_provider") where + toField Enum_certificate_provider_pulse = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "pulse" + toField Enum_certificate_provider_customer = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "customer" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "certificate_provider") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "certificate_provider") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "pulse" -> pure Enum_certificate_provider_pulse + Just "customer" -> pure Enum_certificate_provider_customer + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "check_aggregation" + = Enum_check_aggregation_min + | Enum_check_aggregation_max + | Enum_check_aggregation_sum + | Enum_check_aggregation_avg + | Enum_check_aggregation_count + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "check_aggregation") where + toField Enum_check_aggregation_min = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "min" + toField Enum_check_aggregation_max = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "max" + toField Enum_check_aggregation_sum = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "sum" + toField Enum_check_aggregation_avg = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "avg" + toField Enum_check_aggregation_count = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "count" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "check_aggregation") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "check_aggregation") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "min" -> pure Enum_check_aggregation_min + Just "max" -> pure Enum_check_aggregation_max + Just "sum" -> pure Enum_check_aggregation_sum + Just "avg" -> pure Enum_check_aggregation_avg + Just "count" -> pure Enum_check_aggregation_count + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "check_op" + = Enum_check_op_eq + | Enum_check_op_neq + | Enum_check_op_lt + | Enum_check_op_le + | Enum_check_op_gt + | Enum_check_op_ge + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "check_op") where + toField Enum_check_op_eq = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "eq" + toField Enum_check_op_neq = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "neq" + toField Enum_check_op_lt = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "lt" + toField Enum_check_op_le = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "le" + toField Enum_check_op_gt = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "gt" + toField Enum_check_op_ge = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "ge" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "check_op") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "check_op") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "eq" -> pure Enum_check_op_eq + Just "neq" -> pure Enum_check_op_neq + Just "lt" -> pure Enum_check_op_lt + Just "le" -> pure Enum_check_op_le + Just "gt" -> pure Enum_check_op_gt + Just "ge" -> pure Enum_check_op_ge + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "incident_status" + = Enum_incident_status_created + | Enum_incident_status_unacknowledged + | Enum_incident_status_acknowledged + | Enum_incident_status_resolved + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "incident_status") where + toField Enum_incident_status_created = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "created" + toField Enum_incident_status_unacknowledged = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "unacknowledged" + toField Enum_incident_status_acknowledged = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "acknowledged" + toField Enum_incident_status_resolved = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "resolved" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "incident_status") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "incident_status") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "created" -> pure Enum_incident_status_created + Just "unacknowledged" -> pure Enum_incident_status_unacknowledged + Just "acknowledged" -> pure Enum_incident_status_acknowledged + Just "resolved" -> pure Enum_incident_status_resolved + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + +data instance Enum "event_type" + = Enum_event_type_incident_started + | Enum_event_type_incident_acknowledged + | Enum_event_type_incident_resolved + | Enum_event_type_monitor_failed + | Enum_event_type_monitor_recovered + | Enum_event_type_email_notification_sent + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "event_type") where + toField Enum_event_type_incident_started = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "incident_started" + toField Enum_event_type_incident_acknowledged = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "incident_acknowledged" + toField Enum_event_type_incident_resolved = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "incident_resolved" + toField Enum_event_type_monitor_failed = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "monitor_failed" + toField Enum_event_type_monitor_recovered = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "monitor_recovered" + toField Enum_event_type_email_notification_sent = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "email_notification_sent" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "event_type") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "event_type") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "incident_started" -> pure Enum_event_type_incident_started + Just "incident_acknowledged" -> pure Enum_event_type_incident_acknowledged + Just "incident_resolved" -> pure Enum_event_type_incident_resolved + Just "monitor_failed" -> pure Enum_event_type_monitor_failed + Just "monitor_recovered" -> pure Enum_event_type_monitor_recovered + Just "email_notification_sent" -> pure Enum_event_type_email_notification_sent + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + diff --git a/test/golden/out/Pulse/Database/UnpauseMonitor.hs b/test/golden/out/Pulse/Database/UnpauseMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/UnpauseMonitor.hs @@ -0,0 +1,42 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.UnpauseMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_unpauseMonitor :: Query "unpauseMonitor" ":exec" +query_unpauseMonitor = Query "UPDATE\n monitors\nSET\n is_active = true,\n updated_at = NOW()\nWHERE\n monitors.id = ?" + +data instance Params "unpauseMonitor" = Params_unpauseMonitor + { + monitors_id :: Data.Int.Int32 + } + +data instance Result "unpauseMonitor" = Result_unpauseMonitor + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "unpauseMonitor") where + toRow Params_unpauseMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField monitors_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "unpauseMonitor") where + fromRow = + pure Result_unpauseMonitor + + diff --git a/test/golden/out/Pulse/Database/UpdateEscalationNotificationStatus.hs b/test/golden/out/Pulse/Database/UpdateEscalationNotificationStatus.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/UpdateEscalationNotificationStatus.hs @@ -0,0 +1,50 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.UpdateEscalationNotificationStatus where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified Data.Foldable + +query_updateEscalationNotificationStatus :: Query "updateEscalationNotificationStatus" ":exec" +query_updateEscalationNotificationStatus = Query "UPDATE escalation_notifications\nSET\n delivery_status = ?,\n error_message = COALESCE(?::TEXT, error_message)\nWHERE id = ?" + +data instance Params "updateEscalationNotificationStatus" = Params_updateEscalationNotificationStatus + { + escalation_notifications_id :: Data.Int.Int64, + escalation_notifications_delivery_status :: GHC.Base.Maybe Data.Text.Text, + error_message :: GHC.Base.Maybe Data.Text.Text + } + +data instance Result "updateEscalationNotificationStatus" = Result_updateEscalationNotificationStatus + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "updateEscalationNotificationStatus") where + toRow Params_updateEscalationNotificationStatus{..} = + [ + Database.PostgreSQL.Simple.ToField.toField escalation_notifications_delivery_status, + + Database.PostgreSQL.Simple.ToField.toField error_message, + + Database.PostgreSQL.Simple.ToField.toField escalation_notifications_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "updateEscalationNotificationStatus") where + fromRow = + pure Result_updateEscalationNotificationStatus + + diff --git a/test/golden/out/Pulse/Database/UpdateEscalationPolicy.hs b/test/golden/out/Pulse/Database/UpdateEscalationPolicy.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/UpdateEscalationPolicy.hs @@ -0,0 +1,71 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.UpdateEscalationPolicy where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_updateEscalationPolicy :: Query "updateEscalationPolicy" ":one" +query_updateEscalationPolicy = Query "UPDATE escalation_policies\nSET\n name = COALESCE(?::TEXT, escalation_policies.name),\n description = COALESCE(?::TEXT, escalation_policies.description),\n is_default = COALESCE(?::BOOLEAN, escalation_policies.is_default),\n updated_at = NOW()\nWHERE id = ? AND NOT is_deleted\nRETURNING id, organization_id, name, description, is_default, is_deleted, created_at, updated_at" + +data instance Params "updateEscalationPolicy" = Params_updateEscalationPolicy + { + escalation_policies_id :: Data.Int.Int32, + name :: GHC.Base.Maybe Data.Text.Text, + description :: GHC.Base.Maybe Data.Text.Text, + is_default :: GHC.Base.Maybe GHC.Types.Bool + } + +data instance Result "updateEscalationPolicy" = Result_updateEscalationPolicy + { + escalation_policies_id :: !(Data.Int.Int32), + escalation_policies_organization_id :: !(Data.Int.Int32), + escalation_policies_name :: !(Data.Text.Text), + escalation_policies_description :: !(GHC.Base.Maybe Data.Text.Text), + escalation_policies_is_default :: !(GHC.Types.Bool), + escalation_policies_is_deleted :: !(GHC.Types.Bool), + escalation_policies_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_policies_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "updateEscalationPolicy") where + toRow Params_updateEscalationPolicy{..} = + [ + Database.PostgreSQL.Simple.ToField.toField name, + + Database.PostgreSQL.Simple.ToField.toField description, + + Database.PostgreSQL.Simple.ToField.toField is_default, + + Database.PostgreSQL.Simple.ToField.toField escalation_policies_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "updateEscalationPolicy") where + fromRow = + pure Result_updateEscalationPolicy + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/UpdateEscalationStep.hs b/test/golden/out/Pulse/Database/UpdateEscalationStep.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/UpdateEscalationStep.hs @@ -0,0 +1,85 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.UpdateEscalationStep where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified GHC.Base +import qualified Data.Time.LocalTime +import qualified GHC.Types +import qualified Data.Text +import qualified Data.Time +import qualified Data.Foldable + +query_updateEscalationStep :: Query "updateEscalationStep" ":one" +query_updateEscalationStep = Query "UPDATE escalation_steps\nSET\n step_order = COALESCE(?::INTEGER, escalation_steps.step_order),\n delay_interval = COALESCE(?::INTERVAL, escalation_steps.delay_interval),\n notify_by_email = COALESCE(?::BOOLEAN, escalation_steps.notify_by_email),\n notify_by_push = COALESCE(?::BOOLEAN, escalation_steps.notify_by_push),\n notify_by_critical_alert = COALESCE(?::BOOLEAN, escalation_steps.notify_by_critical_alert),\n message_template = COALESCE(?::TEXT, escalation_steps.message_template),\n updated_at = NOW()\nWHERE id = ?\nRETURNING id, escalation_policy_id, step_order, delay_interval, notify_by_email, notify_by_push, notify_by_critical_alert, message_template, created_at, updated_at" + +data instance Params "updateEscalationStep" = Params_updateEscalationStep + { + escalation_steps_id :: Data.Int.Int32, + step_order :: GHC.Base.Maybe Data.Int.Int32, + delay_interval :: (Maybe Data.Time.LocalTime.CalendarDiffTime), + notify_by_email :: GHC.Base.Maybe GHC.Types.Bool, + notify_by_push :: GHC.Base.Maybe GHC.Types.Bool, + notify_by_critical_alert :: GHC.Base.Maybe GHC.Types.Bool, + message_template :: GHC.Base.Maybe Data.Text.Text + } + +data instance Result "updateEscalationStep" = Result_updateEscalationStep + { + escalation_steps_id :: !(Data.Int.Int32), + escalation_steps_escalation_policy_id :: !(Data.Int.Int32), + escalation_steps_step_order :: !(Data.Int.Int32), + escalation_steps_delay_interval :: !(Data.Time.LocalTime.CalendarDiffTime), + escalation_steps_notify_by_email :: !(GHC.Types.Bool), + escalation_steps_notify_by_push :: !(GHC.Types.Bool), + escalation_steps_notify_by_critical_alert :: !(GHC.Types.Bool), + escalation_steps_message_template :: !(GHC.Base.Maybe Data.Text.Text), + escalation_steps_created_at :: !((Maybe Data.Time.UTCTime)), + escalation_steps_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "updateEscalationStep") where + toRow Params_updateEscalationStep{..} = + [ + Database.PostgreSQL.Simple.ToField.toField step_order, + + Database.PostgreSQL.Simple.ToField.toField delay_interval, + + Database.PostgreSQL.Simple.ToField.toField notify_by_email, + + Database.PostgreSQL.Simple.ToField.toField notify_by_push, + + Database.PostgreSQL.Simple.ToField.toField notify_by_critical_alert, + + Database.PostgreSQL.Simple.ToField.toField message_template, + + Database.PostgreSQL.Simple.ToField.toField escalation_steps_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "updateEscalationStep") where + fromRow = + pure Result_updateEscalationStep + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/UpdateIncidentEscalation.hs b/test/golden/out/Pulse/Database/UpdateIncidentEscalation.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/UpdateIncidentEscalation.hs @@ -0,0 +1,80 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.UpdateIncidentEscalation where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified GHC.Base +import qualified Data.Time +import qualified GHC.Types +import qualified Data.Foldable + +query_updateIncidentEscalation :: Query "updateIncidentEscalation" ":one" +query_updateIncidentEscalation = Query "UPDATE incident_escalations\nSET\n current_step = COALESCE(?::INTEGER, incident_escalations.current_step),\n next_escalation_at = COALESCE(?::TIMESTAMP WITH TIME ZONE, incident_escalations.next_escalation_at),\n is_active = COALESCE(?::BOOLEAN, incident_escalations.is_active),\n updated_at = NOW()\nWHERE id = ?\nRETURNING id, escalation_policy_id, current_step, escalation_started_at, next_escalation_at, is_active, threshold, failed_checks, incident_notification_sent_at, resolved_notification_sent_at, acknowledged_notification_sent_at, created_at, updated_at" + +data instance Params "updateIncidentEscalation" = Params_updateIncidentEscalation + { + incident_escalations_id :: Data.Int.Int64, + current_step :: GHC.Base.Maybe Data.Int.Int32, + next_escalation_at :: (Maybe Data.Time.UTCTime), + is_active :: GHC.Base.Maybe GHC.Types.Bool + } + +data instance Result "updateIncidentEscalation" = Result_updateIncidentEscalation + { + incident_escalations_id :: !(Data.Int.Int64), + incident_escalations_escalation_policy_id :: !(Data.Int.Int32), + incident_escalations_current_step :: !(Data.Int.Int32), + incident_escalations_escalation_started_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_next_escalation_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_is_active :: !(GHC.Types.Bool), + incident_escalations_threshold :: !(Data.Int.Int32), + incident_escalations_failed_checks :: !(Data.Int.Int32), + incident_escalations_incident_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_resolved_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_acknowledged_notification_sent_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_created_at :: !((Maybe Data.Time.UTCTime)), + incident_escalations_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "updateIncidentEscalation") where + toRow Params_updateIncidentEscalation{..} = + [ + Database.PostgreSQL.Simple.ToField.toField current_step, + + Database.PostgreSQL.Simple.ToField.toField next_escalation_at, + + Database.PostgreSQL.Simple.ToField.toField is_active, + + Database.PostgreSQL.Simple.ToField.toField incident_escalations_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "updateIncidentEscalation") where + fromRow = + pure Result_updateIncidentEscalation + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/UpdateMonitor.hs b/test/golden/out/Pulse/Database/UpdateMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/UpdateMonitor.hs @@ -0,0 +1,82 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.UpdateMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified Pulse.Database.Types +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_updateMonitor :: Query "updateMonitor" ":one" +query_updateMonitor = Query "UPDATE\n monitors\nSET\n name = COALESCE(?::TEXT, monitors.name),\n threshold_failures = COALESCE(?::INTEGER, monitors.threshold_failures),\n healthiness = COALESCE(?::monitor_healthiness, monitors.healthiness),\n last_checked = NULL,\n updated_at = NOW()\nWHERE\n monitors.id = ?\nRETURNING id, organization_id, name, type, healthiness, monitor_group, threshold_failures, is_active, is_deleted, last_checked, created_at, updated_at, escalation_policy_id" + +data instance Params "updateMonitor" = Params_updateMonitor + { + monitors_id :: Data.Int.Int32, + name :: GHC.Base.Maybe Data.Text.Text, + threshold_failures :: GHC.Base.Maybe Data.Int.Int32, + healthiness :: GHC.Base.Maybe ((Pulse.Database.Types.Enum "monitor_healthiness")) + } + +data instance Result "updateMonitor" = Result_updateMonitor + { + monitors_id :: !(Data.Int.Int32), + monitors_organization_id :: !(Data.Int.Int32), + monitors_name :: !(Data.Text.Text), + monitors_type :: !((Pulse.Database.Types.Enum "monitor_type")), + monitors_healthiness :: !((Pulse.Database.Types.Enum "monitor_healthiness")), + monitors_monitor_group :: !(Data.Text.Text), + monitors_threshold_failures :: !(Data.Int.Int32), + monitors_is_active :: !(GHC.Types.Bool), + monitors_is_deleted :: !(GHC.Types.Bool), + monitors_last_checked :: !((Maybe Data.Time.UTCTime)), + monitors_created_at :: !((Maybe Data.Time.UTCTime)), + monitors_updated_at :: !((Maybe Data.Time.UTCTime)), + monitors_escalation_policy_id :: !(Data.Int.Int32) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "updateMonitor") where + toRow Params_updateMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField name, + + Database.PostgreSQL.Simple.ToField.toField threshold_failures, + + Database.PostgreSQL.Simple.ToField.toField healthiness, + + Database.PostgreSQL.Simple.ToField.toField monitors_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "updateMonitor") where + fromRow = + pure Result_updateMonitor + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/UpdateNewOpcuaEndpointMonitor.hs b/test/golden/out/Pulse/Database/UpdateNewOpcuaEndpointMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/UpdateNewOpcuaEndpointMonitor.hs @@ -0,0 +1,84 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.UpdateNewOpcuaEndpointMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Text +import qualified Pulse.Database.Types +import qualified Data.Int +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_updateNewOpcuaEndpointMonitor :: Query "updateNewOpcuaEndpointMonitor" ":one" +query_updateNewOpcuaEndpointMonitor = Query "UPDATE\n opcua_endpoint_monitors\nSET\n endpoint = ?,\n mode = ?,\n policy = ?,\n certificate = ?,\n credentials = ?,\n incident_message_template = ?,\n updated_at = NOW()\nWHERE\n opcua_endpoint_monitors.id = ?\nRETURNING id, endpoint, mode, policy, certificate, credentials, incident_message_template, latest_connection_attempt, created_at, updated_at" + +data instance Params "updateNewOpcuaEndpointMonitor" = Params_updateNewOpcuaEndpointMonitor + { + opcua_endpoint_monitors_endpoint :: Data.Text.Text, + opcua_endpoint_monitors_mode :: (Pulse.Database.Types.Enum "opcua_security_mode"), + opcua_endpoint_monitors_policy :: (Pulse.Database.Types.Enum "opcua_security_policy"), + opcua_endpoint_monitors_certificate :: GHC.Base.Maybe Data.Int.Int32, + opcua_endpoint_monitors_credentials :: GHC.Base.Maybe Data.Int.Int32, + opcua_endpoint_monitors_incident_message_template :: GHC.Base.Maybe Data.Text.Text, + opcua_endpoint_monitors_id :: Data.Int.Int32 + } + +data instance Result "updateNewOpcuaEndpointMonitor" = Result_updateNewOpcuaEndpointMonitor + { + opcua_endpoint_monitors_id :: !(Data.Int.Int32), + opcua_endpoint_monitors_endpoint :: !(Data.Text.Text), + opcua_endpoint_monitors_mode :: !((Pulse.Database.Types.Enum "opcua_security_mode")), + opcua_endpoint_monitors_policy :: !((Pulse.Database.Types.Enum "opcua_security_policy")), + opcua_endpoint_monitors_certificate :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_credentials :: !(GHC.Base.Maybe Data.Int.Int32), + opcua_endpoint_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_endpoint_monitors_latest_connection_attempt :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_endpoint_monitors_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "updateNewOpcuaEndpointMonitor") where + toRow Params_updateNewOpcuaEndpointMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_endpoint, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_mode, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_policy, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_certificate, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_credentials, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_incident_message_template, + + Database.PostgreSQL.Simple.ToField.toField opcua_endpoint_monitors_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "updateNewOpcuaEndpointMonitor") where + fromRow = + pure Result_updateNewOpcuaEndpointMonitor + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/UpdateOpcuaNodeMonitor.hs b/test/golden/out/Pulse/Database/UpdateOpcuaNodeMonitor.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/UpdateOpcuaNodeMonitor.hs @@ -0,0 +1,94 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.UpdateOpcuaNodeMonitor where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified GHC.Base +import qualified Pulse.Database.DBTypes +import qualified Pulse.Database.Types +import qualified Data.Text +import qualified Data.Time.LocalTime +import qualified Data.Time +import qualified Data.Foldable + +query_updateOpcuaNodeMonitor :: Query "updateOpcuaNodeMonitor" ":one" +query_updateOpcuaNodeMonitor = Query "UPDATE opcua_node_monitors\nSET\n endpoint_monitor_id = COALESCE(?::INT, opcua_node_monitors.endpoint_monitor_id),\n opcua_node_id = COALESCE(?::opcua_node_id, opcua_node_monitors.opcua_node_id),\n aggregation = COALESCE(?::check_aggregation, opcua_node_monitors.aggregation),\n operand = COALESCE(?::TEXT, opcua_node_monitors.operand),\n operation = COALESCE(?::check_op, opcua_node_monitors.operation),\n duration = COALESCE(?::INTERVAL, opcua_node_monitors.duration),\n frequency = COALESCE(?::INTERVAL, opcua_node_monitors.frequency),\n incident_message_template = COALESCE(?::TEXT, opcua_node_monitors.incident_message_template)\nWHERE id = ?\nRETURNING id, endpoint_monitor_id, opcua_node_id, aggregation, operation, operand, duration, frequency, incident_message_template, created_at, updated_at" + +data instance Params "updateOpcuaNodeMonitor" = Params_updateOpcuaNodeMonitor + { + opcua_node_monitors_id :: Data.Int.Int32, + endpoint_monitor_id :: GHC.Base.Maybe Data.Int.Int32, + opcua_node_id :: (Maybe Pulse.Database.DBTypes.OpcuaNodeId), + aggregation :: GHC.Base.Maybe ((Pulse.Database.Types.Enum "check_aggregation")), + operand :: GHC.Base.Maybe Data.Text.Text, + operation :: GHC.Base.Maybe ((Pulse.Database.Types.Enum "check_op")), + duration :: (Maybe Data.Time.LocalTime.CalendarDiffTime), + frequency :: (Maybe Data.Time.LocalTime.CalendarDiffTime), + incident_message_template :: GHC.Base.Maybe Data.Text.Text + } + +data instance Result "updateOpcuaNodeMonitor" = Result_updateOpcuaNodeMonitor + { + opcua_node_monitors_id :: !(Data.Int.Int32), + opcua_node_monitors_endpoint_monitor_id :: !(Data.Int.Int32), + opcua_node_monitors_opcua_node_id :: !(Pulse.Database.DBTypes.OpcuaNodeId), + opcua_node_monitors_aggregation :: !((Pulse.Database.Types.Enum "check_aggregation")), + opcua_node_monitors_operation :: !((Pulse.Database.Types.Enum "check_op")), + opcua_node_monitors_operand :: !(Data.Text.Text), + opcua_node_monitors_duration :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_frequency :: !(Data.Time.LocalTime.CalendarDiffTime), + opcua_node_monitors_incident_message_template :: !(GHC.Base.Maybe Data.Text.Text), + opcua_node_monitors_created_at :: !((Maybe Data.Time.UTCTime)), + opcua_node_monitors_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "updateOpcuaNodeMonitor") where + toRow Params_updateOpcuaNodeMonitor{..} = + [ + Database.PostgreSQL.Simple.ToField.toField endpoint_monitor_id, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_id, + + Database.PostgreSQL.Simple.ToField.toField aggregation, + + Database.PostgreSQL.Simple.ToField.toField operand, + + Database.PostgreSQL.Simple.ToField.toField operation, + + Database.PostgreSQL.Simple.ToField.toField duration, + + Database.PostgreSQL.Simple.ToField.toField frequency, + + Database.PostgreSQL.Simple.ToField.toField incident_message_template, + + Database.PostgreSQL.Simple.ToField.toField opcua_node_monitors_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "updateOpcuaNodeMonitor") where + fromRow = + pure Result_updateOpcuaNodeMonitor + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/Pulse/Database/UpdateSeverity.hs b/test/golden/out/Pulse/Database/UpdateSeverity.hs new file mode 100644 --- /dev/null +++ b/test/golden/out/Pulse/Database/UpdateSeverity.hs @@ -0,0 +1,74 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.UpdateSeverity where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_updateSeverity :: Query "updateSeverity" ":one" +query_updateSeverity = Query "UPDATE severities\nSET\n name = COALESCE(?::TEXT, severities.name),\n notify_by_email = COALESCE(?::BOOLEAN, severities.notify_by_email),\n notify_by_push = COALESCE(?::BOOLEAN, severities.notify_by_push),\n notify_by_critical_alert = COALESCE(?::BOOLEAN, severities.notify_by_critical_alert),\n updated_at = NOW()\nWHERE id = ?\nRETURNING id, team_id, name, notify_by_email, notify_by_push, notify_by_critical_alert, created_at, updated_at" + +data instance Params "updateSeverity" = Params_updateSeverity + { + severities_id :: Data.Int.Int32, + name :: GHC.Base.Maybe Data.Text.Text, + notify_by_email :: GHC.Base.Maybe GHC.Types.Bool, + notify_by_push :: GHC.Base.Maybe GHC.Types.Bool, + notify_by_critical_alert :: GHC.Base.Maybe GHC.Types.Bool + } + +data instance Result "updateSeverity" = Result_updateSeverity + { + severities_id :: !(Data.Int.Int32), + severities_team_id :: !(Data.Int.Int32), + severities_name :: !(Data.Text.Text), + severities_notify_by_email :: !(GHC.Types.Bool), + severities_notify_by_push :: !(GHC.Types.Bool), + severities_notify_by_critical_alert :: !(GHC.Types.Bool), + severities_created_at :: !((Maybe Data.Time.UTCTime)), + severities_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "updateSeverity") where + toRow Params_updateSeverity{..} = + [ + Database.PostgreSQL.Simple.ToField.toField name, + + Database.PostgreSQL.Simple.ToField.toField notify_by_email, + + Database.PostgreSQL.Simple.ToField.toField notify_by_push, + + Database.PostgreSQL.Simple.ToField.toField notify_by_critical_alert, + + Database.PostgreSQL.Simple.ToField.toField severities_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "updateSeverity") where + fromRow = + pure Result_updateSeverity + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/out/pulse-db.cabal b/test/golden/out/pulse-db.cabal new file mode 100644 --- /dev/null +++ b/test/golden/out/pulse-db.cabal @@ -0,0 +1,103 @@ +cabal-version: 3.0 +name: pulse-db +version: 0.1.0.0 +library + build-depends: + base, + bytestring, + ghc-prim, + postgresql-simple, + pulse-db-types, + scientific, + text, + time, + vector, + exposed-modules: + Pulse.Database + Pulse.Database.CreateIncidentEscalation + Pulse.Database.CreateIncidentFromMonitorIfNotExists + Pulse.Database.CreateIncidentWithEscalation + Pulse.Database.CreateOpcuaEndpointIncident + Pulse.Database.CreateOpcuaNodeIncident + Pulse.Database.DeleteAgedSamples + Pulse.Database.DeleteEscalationPolicy + Pulse.Database.DeleteEscalationStep + Pulse.Database.DeleteMonitor + Pulse.Database.DeleteSeverity + Pulse.Database.FlipMonitorHealthiness + Pulse.Database.FlopMonitorHealthiness + Pulse.Database.GetAcknowledgedIncidentsForNotification + Pulse.Database.GetDefaultEscalationPolicy + Pulse.Database.GetEscalationPolicies + Pulse.Database.GetEscalationPolicyById + Pulse.Database.GetEscalationSteps + Pulse.Database.GetExpiredHeartbeatMonitors + Pulse.Database.GetHeartbeatMonitors + Pulse.Database.GetIncidentEscalation + Pulse.Database.GetIncidentEvents + Pulse.Database.GetIncidents + Pulse.Database.GetIncidentsToEscalate + Pulse.Database.GetLatestSampledOpcuaAttributeValues + Pulse.Database.GetLoginByEmail + Pulse.Database.GetLoginById + Pulse.Database.GetLoginOrganization + Pulse.Database.GetLoginOrganizations + Pulse.Database.GetLoginTeams + Pulse.Database.GetMonitors + Pulse.Database.GetOpcuaAttributeAggregates + Pulse.Database.GetOpcuaAttributeValuesForTimeRange + Pulse.Database.GetOpcuaEndpointCertificates + Pulse.Database.GetOpcuaEndpointCredentials + Pulse.Database.GetOpcuaEndpointMonitors + Pulse.Database.GetOpcuaEndpointMonitorsToCheck + Pulse.Database.GetOpcuaEndpointMonitorsToSample + Pulse.Database.GetOpcuaNodeMonitors + Pulse.Database.GetOpcuaNodeMonitorsToCheck + Pulse.Database.GetOpcuaNodeMonitorsToSample + Pulse.Database.GetOrganizations + Pulse.Database.GetRecoveredHeartbearMonitors + Pulse.Database.GetResolvedIncidentsForNotification + Pulse.Database.GetSeverities + Pulse.Database.GetSeverityById + Pulse.Database.GetTeamById + Pulse.Database.GetTeamByInvitationCode + Pulse.Database.GetTeamByName + Pulse.Database.GetTeamMembers + Pulse.Database.GetTeams + Pulse.Database.InsertDefaultTeamIfNotExists + Pulse.Database.InsertEscalationNotification + Pulse.Database.InsertEscalationPolicy + Pulse.Database.InsertEscalationStep + Pulse.Database.InsertLogin + Pulse.Database.InsertNewMonitor + Pulse.Database.InsertNewOpcuaEndpointMonitor + Pulse.Database.InsertOpcuaAttributeValue + Pulse.Database.InsertOpcuaEndpointCertificate + Pulse.Database.InsertOpcuaEndpointCredentials + Pulse.Database.InsertOpcuaNodeMonitor + Pulse.Database.InsertOrganizationLogin + Pulse.Database.InsertSeverity + Pulse.Database.InsertTeam + Pulse.Database.InsertTeamMember + Pulse.Database.Internal + Pulse.Database.MarkAcknowledgedNotificationSent + Pulse.Database.MarkIncidentNotificationSent + Pulse.Database.MarkResolvedNotificationSent + Pulse.Database.PauseIncidentEscalation + Pulse.Database.PauseMonitor + Pulse.Database.ResolveIncidentsByFailingMonitors + Pulse.Database.ResumeIncidentEscalation + Pulse.Database.SetIncidentToAcknowledged + Pulse.Database.TickleHeartbeatMonitor + Pulse.Database.Types + Pulse.Database.UnpauseMonitor + Pulse.Database.UpdateEscalationNotificationStatus + Pulse.Database.UpdateEscalationPolicy + Pulse.Database.UpdateEscalationStep + Pulse.Database.UpdateIncidentEscalation + Pulse.Database.UpdateMonitor + Pulse.Database.UpdateNewOpcuaEndpointMonitor + Pulse.Database.UpdateOpcuaNodeMonitor + Pulse.Database.UpdateSeverity + default-extensions: + NoFieldSelectors diff --git a/test/golden/pulse.input b/test/golden/pulse.input new file mode 100644 --- /dev/null +++ b/test/golden/pulse.input @@ -0,0 +1,24829 @@ +settings { + version: "2" + engine: "postgresql" + schema: "db/migrations" + queries: "db/queries.sql" + codegen { + out: "pulse-db" + plugin: "haskell" + options: "{\"cabal_default_extensions\":[\"NoFieldSelectors\"],\"cabal_package_name\":\"pulse-db\",\"haskell_module_prefix\":\"Pulse.Database\",\"overrides\":[{\"db_type\":\"pg_catalog.timestamptz\",\"haskell_type\":{\"module\":\"Data.Time\",\"package\":\"time\",\"type\":\"Data.Time.UTCTime\"}}]}" + process { cmd: "./dump-proto.sh" } + } +} +catalog { + default_schema: "public" + schemas { + name: "public" + tables { + rel { name: "organizations" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "serial" } + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "text" } + } + columns { + name: "created_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "logins" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "serial" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + } + columns { + name: "login_name" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "organization_logins" } + columns { + name: "login_id" + not_null: true + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "role" + not_null: true + length: -1 + table { name: "organization_logins" } + type { name: "organization_role" } + } + columns { + name: "created_at" + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "organization_logins" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "teams" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "serial" } + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "team_members" } + columns { + name: "team_id" + not_null: true + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "login_id" + not_null: true + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "created_at" + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + tables { + rel { name: "incident" } + columns { + name: "id" + not_null: true + length: -1 + table { name: "incident" } + type { name: "serial8" } + } + columns { + name: "tenant_id" + not_null: true + length: -1 + table { name: "incident" } + type { schema: "pg_catalog" name: "int4" } + } + columns { + name: "status" + length: -1 + table { name: "incident" } + type { name: "text" } + } + columns { + name: "name" + length: -1 + table { name: "incident" } + type { name: "text" } + } + columns { + name: "started_at" + length: -1 + table { name: "incident" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "created_at" + length: -1 + table { name: "incident" } + type { schema: "pg_catalog" name: "timestamptz" } + } + columns { + name: "updated_at" + length: -1 + table { name: "incident" } + type { schema: "pg_catalog" name: "timestamptz" } + } + } + enums { + name: "organization_role" + vals: "owner" + vals: "admin" + vals: "member" + } + } + schemas { name: "pg_temp" } + schemas { + name: "pg_catalog" + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "tid" } + } + columns { + name: "aggfnoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggkind" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "char" } + } + columns { + name: "aggnumdirectargs" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "int2" } + } + columns { + name: "aggtransfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggfinalfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggcombinefn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggserialfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggdeserialfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggmtransfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggminvtransfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggmfinalfn" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "regproc" } + } + columns { + name: "aggfinalextra" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "bool" } + } + columns { + name: "aggmfinalextra" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "bool" } + } + columns { + name: "aggfinalmodify" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "char" } + } + columns { + name: "aggmfinalmodify" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "char" } + } + columns { + name: "aggsortop" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "oid" } + } + columns { + name: "aggtranstype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "oid" } + } + columns { + name: "aggtransspace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "int4" } + } + columns { + name: "aggmtranstype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "oid" } + } + columns { + name: "aggmtransspace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "int4" } + } + columns { + name: "agginitval" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "text" } + } + columns { + name: "aggminitval" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_aggregate" + } + type { name: "text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "oid" } + } + columns { + name: "amname" + not_null: true + length: 64 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "name" } + } + columns { + name: "amhandler" + not_null: true + length: 4 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "regproc" } + } + columns { + name: "amtype" + not_null: true + length: 1 + table { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_am" } + type { name: "char" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amopfamily" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amoplefttype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amoprighttype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amopstrategy" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "int2" } + } + columns { + name: "amoppurpose" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "char" } + } + columns { + name: "amopopr" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amopmethod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + columns { + name: "amopsortfamily" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amop" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "amprocfamily" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "amproclefttype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "amprocrighttype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "oid" } + } + columns { + name: "amprocnum" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "int2" } + } + columns { + name: "amproc" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_amproc" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "oid" } + } + columns { + name: "adrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "oid" } + } + columns { + name: "adnum" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "int2" } + } + columns { + name: "adbin" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attrdef" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "tid" } + } + columns { + name: "attrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "oid" } + } + columns { + name: "attname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "name" } + } + columns { + name: "atttypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "oid" } + } + columns { + name: "attstattarget" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "attlen" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int2" } + } + columns { + name: "attnum" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int2" } + } + columns { + name: "attndims" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "attcacheoff" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "atttypmod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "attbyval" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "attalign" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attstorage" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attcompression" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attnotnull" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "atthasdef" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "atthasmissing" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "attidentity" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attgenerated" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "char" } + } + columns { + name: "attisdropped" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "attislocal" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "bool" } + } + columns { + name: "attinhcount" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "int4" } + } + columns { + name: "attcollation" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "oid" } + } + columns { + name: "attacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "_aclitem" } + } + columns { + name: "attoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "_text" } + } + columns { + name: "attfdwoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "_text" } + } + columns { + name: "attmissingval" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_attribute" + } + type { name: "anyarray" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "tid" } + } + columns { + name: "roleid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "oid" } + } + columns { + name: "member" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "oid" } + } + columns { + name: "grantor" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "oid" } + } + columns { + name: "admin_option" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_auth_members" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "oid" } + } + columns { + name: "rolname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "name" } + } + columns { + name: "rolsuper" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolinherit" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolcreaterole" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolcreatedb" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolcanlogin" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolreplication" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolbypassrls" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "bool" } + } + columns { + name: "rolconnlimit" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "int4" } + } + columns { + name: "rolpassword" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "text" } + } + columns { + name: "rolvaliduntil" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_authid" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + columns { + name: "name" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "name" } + } + columns { + name: "version" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "text" } + } + columns { + name: "installed" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "bool" } + } + columns { + name: "superuser" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "bool" } + } + columns { + name: "trusted" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "bool" } + } + columns { + name: "relocatable" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "bool" } + } + columns { + name: "schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "name" } + } + columns { + name: "requires" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "_name" } + } + columns { + name: "comment" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extension_versions" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + columns { + name: "name" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + type { name: "name" } + } + columns { + name: "default_version" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + type { name: "text" } + } + columns { + name: "installed_version" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + type { name: "text" } + } + columns { + name: "comment" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_available_extensions" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "text" } + } + columns { + name: "ident" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "text" } + } + columns { + name: "parent" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "text" } + } + columns { + name: "level" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int4" } + } + columns { + name: "total_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + columns { + name: "total_nblocks" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + columns { + name: "free_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + columns { + name: "free_chunks" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + columns { + name: "used_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_backend_memory_contexts" + } + type { name: "int8" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "castsource" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "casttarget" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "castfunc" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "oid" } + } + columns { + name: "castcontext" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "char" } + } + columns { + name: "castmethod" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cast" + } + type { name: "char" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "name" } + } + columns { + name: "relnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "reltype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "reloftype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relam" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relfilenode" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "reltablespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relpages" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "int4" } + } + columns { + name: "reltuples" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "float4" } + } + columns { + name: "relallvisible" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "int4" } + } + columns { + name: "reltoastrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relhasindex" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relisshared" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relpersistence" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "char" } + } + columns { + name: "relkind" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "char" } + } + columns { + name: "relnatts" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "int2" } + } + columns { + name: "relchecks" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "int2" } + } + columns { + name: "relhasrules" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relhastriggers" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relhassubclass" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relrowsecurity" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relforcerowsecurity" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relispopulated" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relreplident" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "char" } + } + columns { + name: "relispartition" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "bool" } + } + columns { + name: "relrewrite" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "oid" } + } + columns { + name: "relfrozenxid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "xid" } + } + columns { + name: "relminmxid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "xid" } + } + columns { + name: "relacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "_aclitem" } + } + columns { + name: "reloptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "_text" } + } + columns { + name: "relpartbound" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_class" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "oid" } + } + columns { + name: "collname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "name" } + } + columns { + name: "collnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "oid" } + } + columns { + name: "collowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "oid" } + } + columns { + name: "collprovider" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "char" } + } + columns { + name: "collisdeterministic" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "bool" } + } + columns { + name: "collencoding" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "int4" } + } + columns { + name: "collcollate" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "text" } + } + columns { + name: "collctype" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "text" } + } + columns { + name: "colliculocale" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "text" } + } + columns { + name: "collversion" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_collation" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_config" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_config" + } + type { name: "text" } + } + columns { + name: "setting" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_config" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "conname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "name" } + } + columns { + name: "connamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "contype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "char" } + } + columns { + name: "condeferrable" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "condeferred" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "convalidated" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "conrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "contypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "conindid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "conparentid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "confrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "oid" } + } + columns { + name: "confupdtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "char" } + } + columns { + name: "confdeltype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "char" } + } + columns { + name: "confmatchtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "char" } + } + columns { + name: "conislocal" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "coninhcount" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "int4" } + } + columns { + name: "connoinherit" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "bool" } + } + columns { + name: "conkey" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_int2" } + } + columns { + name: "confkey" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_int2" } + } + columns { + name: "conpfeqop" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_oid" } + } + columns { + name: "conppeqop" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_oid" } + } + columns { + name: "conffeqop" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_oid" } + } + columns { + name: "confdelsetcols" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_int2" } + } + columns { + name: "conexclop" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "_oid" } + } + columns { + name: "conbin" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_constraint" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "oid" } + } + columns { + name: "conname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "name" } + } + columns { + name: "connamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "oid" } + } + columns { + name: "conowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "oid" } + } + columns { + name: "conforencoding" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "int4" } + } + columns { + name: "contoencoding" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "int4" } + } + columns { + name: "conproc" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "regproc" } + } + columns { + name: "condefault" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_conversion" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "text" } + } + columns { + name: "statement" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "text" } + } + columns { + name: "is_holdable" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "bool" } + } + columns { + name: "is_binary" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "bool" } + } + columns { + name: "is_scrollable" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "bool" } + } + columns { + name: "creation_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_cursors" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "oid" } + } + columns { + name: "datname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "name" } + } + columns { + name: "datdba" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "oid" } + } + columns { + name: "encoding" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "int4" } + } + columns { + name: "datlocprovider" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "char" } + } + columns { + name: "datistemplate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "bool" } + } + columns { + name: "datallowconn" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "bool" } + } + columns { + name: "datconnlimit" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "int4" } + } + columns { + name: "datfrozenxid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "xid" } + } + columns { + name: "datminmxid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "xid" } + } + columns { + name: "dattablespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "oid" } + } + columns { + name: "datcollate" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "text" } + } + columns { + name: "datctype" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "text" } + } + columns { + name: "daticulocale" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "text" } + } + columns { + name: "datcollversion" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "text" } + } + columns { + name: "datacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_database" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "tid" } + } + columns { + name: "setdatabase" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "oid" } + } + columns { + name: "setrole" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "oid" } + } + columns { + name: "setconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_db_role_setting" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "oid" } + } + columns { + name: "defaclrole" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "oid" } + } + columns { + name: "defaclnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "oid" } + } + columns { + name: "defaclobjtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "char" } + } + columns { + name: "defaclacl" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_default_acl" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "tid" } + } + columns { + name: "classid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "objid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "int4" } + } + columns { + name: "refclassid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "refobjid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "oid" } + } + columns { + name: "refobjsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "int4" } + } + columns { + name: "deptype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_depend" + } + type { name: "char" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "int4" } + } + columns { + name: "description" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_description" + } + type { name: "text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "oid" } + } + columns { + name: "enumtypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "oid" } + } + columns { + name: "enumsortorder" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "float4" } + } + columns { + name: "enumlabel" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_enum" + } + type { name: "name" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "oid" } + } + columns { + name: "evtname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "name" } + } + columns { + name: "evtevent" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "name" } + } + columns { + name: "evtowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "oid" } + } + columns { + name: "evtfoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "oid" } + } + columns { + name: "evtenabled" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "char" } + } + columns { + name: "evttags" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_event_trigger" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "oid" } + } + columns { + name: "extname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "name" } + } + columns { + name: "extowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "oid" } + } + columns { + name: "extnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "oid" } + } + columns { + name: "extrelocatable" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "bool" } + } + columns { + name: "extversion" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "text" } + } + columns { + name: "extconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "_oid" } + } + columns { + name: "extcondition" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_extension" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + columns { + name: "sourcefile" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "text" } + } + columns { + name: "sourceline" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "int4" } + } + columns { + name: "seqno" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "int4" } + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "text" } + } + columns { + name: "setting" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "text" } + } + columns { + name: "applied" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "bool" } + } + columns { + name: "error" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_file_settings" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "fdwname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "name" } + } + columns { + name: "fdwowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "fdwhandler" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "fdwvalidator" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "oid" } + } + columns { + name: "fdwacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "_aclitem" } + } + columns { + name: "fdwoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_data_wrapper" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "oid" } + } + columns { + name: "srvname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "name" } + } + columns { + name: "srvowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "oid" } + } + columns { + name: "srvfdw" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "oid" } + } + columns { + name: "srvtype" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "text" } + } + columns { + name: "srvversion" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "text" } + } + columns { + name: "srvacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "_aclitem" } + } + columns { + name: "srvoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_foreign_server" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "tid" } + } + columns { + name: "ftrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "oid" } + } + columns { + name: "ftserver" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "oid" } + } + columns { + name: "ftoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_foreign_table" + } + type { name: "_text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_group" } + columns { + name: "groname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_group" + } + type { name: "name" } + } + columns { + name: "grosysid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_group" + } + type { name: "oid" } + } + columns { + name: "grolist" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_group" + } + type { name: "_oid" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + columns { + name: "line_number" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "int4" } + } + columns { + name: "type" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + columns { + name: "database" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "_text" } + } + columns { + name: "user_name" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "_text" } + } + columns { + name: "address" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + columns { + name: "netmask" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + columns { + name: "auth_method" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + columns { + name: "options" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "_text" } + } + columns { + name: "error" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_hba_file_rules" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + columns { + name: "line_number" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "int4" } + } + columns { + name: "map_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "text" } + } + columns { + name: "sys_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "text" } + } + columns { + name: "pg_username" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "text" } + } + columns { + name: "error" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_ident_file_mappings" + } + type { name: "text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "tid" } + } + columns { + name: "indexrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oid" } + } + columns { + name: "indrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oid" } + } + columns { + name: "indnatts" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "int2" } + } + columns { + name: "indnkeyatts" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "int2" } + } + columns { + name: "indisunique" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indnullsnotdistinct" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisprimary" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisexclusion" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indimmediate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisclustered" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisvalid" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indcheckxmin" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisready" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indislive" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indisreplident" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "bool" } + } + columns { + name: "indkey" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "int2vector" } + } + columns { + name: "indcollation" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oidvector" } + } + columns { + name: "indclass" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "oidvector" } + } + columns { + name: "indoption" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "int2vector" } + } + columns { + name: "indexprs" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "pg_node_tree" } + } + columns { + name: "indpred" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_index" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "name" } + } + columns { + name: "indexname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "name" } + } + columns { + name: "tablespace" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "name" } + } + columns { + name: "indexdef" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_indexes" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "tid" } + } + columns { + name: "inhrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "oid" } + } + columns { + name: "inhparent" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "oid" } + } + columns { + name: "inhseqno" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "int4" } + } + columns { + name: "inhdetachpending" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_inherits" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "int4" } + } + columns { + name: "privtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "char" } + } + columns { + name: "initprivs" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_init_privs" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "lanname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "name" } + } + columns { + name: "lanowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "lanispl" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "bool" } + } + columns { + name: "lanpltrusted" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "bool" } + } + columns { + name: "lanplcallfoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "laninline" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "lanvalidator" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "oid" } + } + columns { + name: "lanacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_language" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "tid" } + } + columns { + name: "loid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "oid" } + } + columns { + name: "pageno" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "int4" } + } + columns { + name: "data" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_largeobject" + } + type { name: "bytea" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "oid" } + } + columns { + name: "lomowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "oid" } + } + columns { + name: "lomacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_largeobject_metadata" + } + type { name: "_aclitem" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" } + columns { + name: "locktype" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "text" } + } + columns { + name: "database" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "oid" } + } + columns { + name: "relation" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "oid" } + } + columns { + name: "page" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "int4" } + } + columns { + name: "tuple" + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "int2" } + } + columns { + name: "virtualxid" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "text" } + } + columns { + name: "transactionid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "xid" } + } + columns { + name: "classid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "oid" } + } + columns { + name: "objid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "oid" } + } + columns { + name: "objsubid" + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "int2" } + } + columns { + name: "virtualtransaction" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "text" } + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "int4" } + } + columns { + name: "mode" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "text" } + } + columns { + name: "granted" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "bool" } + } + columns { + name: "fastpath" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "bool" } + } + columns { + name: "waitstart" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_locks" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "name" } + } + columns { + name: "matviewname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "name" } + } + columns { + name: "matviewowner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "name" } + } + columns { + name: "tablespace" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "name" } + } + columns { + name: "hasindexes" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "bool" } + } + columns { + name: "ispopulated" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "bool" } + } + columns { + name: "definition" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_matviews" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "oid" } + } + columns { + name: "nspname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "name" } + } + columns { + name: "nspowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "oid" } + } + columns { + name: "nspacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_namespace" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcmethod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "name" } + } + columns { + name: "opcnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcfamily" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcintype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + columns { + name: "opcdefault" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "bool" } + } + columns { + name: "opckeytype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opclass" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "name" } + } + columns { + name: "oprnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprkind" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "char" } + } + columns { + name: "oprcanmerge" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "bool" } + } + columns { + name: "oprcanhash" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "bool" } + } + columns { + name: "oprleft" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprright" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprresult" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprcom" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprnegate" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "oid" } + } + columns { + name: "oprcode" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "regproc" } + } + columns { + name: "oprrest" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "regproc" } + } + columns { + name: "oprjoin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_operator" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + columns { + name: "opfmethod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + columns { + name: "opfname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "name" } + } + columns { + name: "opfnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + columns { + name: "opfowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_opfamily" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "oid" } + } + columns { + name: "parname" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "text" } + } + columns { + name: "paracl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_parameter_acl" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "tid" } + } + columns { + name: "partrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oid" } + } + columns { + name: "partstrat" + not_null: true + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "char" } + } + columns { + name: "partnatts" + not_null: true + length: 2 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "int2" } + } + columns { + name: "partdefid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oid" } + } + columns { + name: "partattrs" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "int2vector" } + } + columns { + name: "partclass" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oidvector" } + } + columns { + name: "partcollation" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "oidvector" } + } + columns { + name: "partexprs" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_partitioned_table" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "name" } + } + columns { + name: "policyname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "name" } + } + columns { + name: "permissive" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "text" } + } + columns { + name: "roles" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "_name" } + } + columns { + name: "cmd" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "text" } + } + columns { + name: "qual" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "text" } + } + columns { + name: "with_check" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policies" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "oid" } + } + columns { + name: "polname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "name" } + } + columns { + name: "polrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "oid" } + } + columns { + name: "polcmd" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "char" } + } + columns { + name: "polpermissive" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "bool" } + } + columns { + name: "polroles" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "_oid" } + } + columns { + name: "polqual" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "pg_node_tree" } + } + columns { + name: "polwithcheck" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_policy" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "text" } + } + columns { + name: "statement" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "text" } + } + columns { + name: "prepare_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "timestamptz" } + } + columns { + name: "parameter_types" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "_regtype" } + } + columns { + name: "from_sql" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "bool" } + } + columns { + name: "generic_plans" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "int8" } + } + columns { + name: "custom_plans" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_statements" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + columns { + name: "transaction" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "xid" } + } + columns { + name: "gid" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "text" } + } + columns { + name: "prepared" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "timestamptz" } + } + columns { + name: "owner" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "name" } + } + columns { + name: "database" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_prepared_xacts" + } + type { name: "name" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "proname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "name" } + } + columns { + name: "pronamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "proowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "prolang" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "procost" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "float4" } + } + columns { + name: "prorows" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "float4" } + } + columns { + name: "provariadic" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "prosupport" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "regproc" } + } + columns { + name: "prokind" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "char" } + } + columns { + name: "prosecdef" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "bool" } + } + columns { + name: "proleakproof" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "bool" } + } + columns { + name: "proisstrict" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "bool" } + } + columns { + name: "proretset" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "bool" } + } + columns { + name: "provolatile" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "char" } + } + columns { + name: "proparallel" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "char" } + } + columns { + name: "pronargs" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "int2" } + } + columns { + name: "pronargdefaults" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "int2" } + } + columns { + name: "prorettype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oid" } + } + columns { + name: "proargtypes" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "oidvector" } + } + columns { + name: "proallargtypes" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_oid" } + } + columns { + name: "proargmodes" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_char" } + } + columns { + name: "proargnames" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_text" } + } + columns { + name: "proargdefaults" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "pg_node_tree" } + } + columns { + name: "protrftypes" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_oid" } + } + columns { + name: "prosrc" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "text" } + } + columns { + name: "probin" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "text" } + } + columns { + name: "prosqlbody" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "pg_node_tree" } + } + columns { + name: "proconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_text" } + } + columns { + name: "proacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_proc" + } + type { name: "_aclitem" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "oid" } + } + columns { + name: "pubname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "name" } + } + columns { + name: "pubowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "oid" } + } + columns { + name: "puballtables" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubinsert" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubupdate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubdelete" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubtruncate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + columns { + name: "pubviaroot" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_publication" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "oid" } + } + columns { + name: "pnpubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "oid" } + } + columns { + name: "pnnspid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_namespace" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "oid" } + } + columns { + name: "prpubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "oid" } + } + columns { + name: "prrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "oid" } + } + columns { + name: "prqual" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "pg_node_tree" } + } + columns { + name: "prattrs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_rel" + } + type { name: "int2vector" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + columns { + name: "pubname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "name" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "name" } + } + columns { + name: "attnames" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "_name" } + } + columns { + name: "rowfilter" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_publication_tables" + } + type { name: "text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "tid" } + } + columns { + name: "rngtypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngsubtype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngmultitypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngcollation" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngsubopc" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "oid" } + } + columns { + name: "rngcanonical" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "regproc" } + } + columns { + name: "rngsubdiff" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_range" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "tid" } + } + columns { + name: "roident" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "oid" } + } + columns { + name: "roname" + not_null: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + columns { + name: "local_id" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + type { name: "oid" } + } + columns { + name: "external_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + type { name: "text" } + } + columns { + name: "remote_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + type { name: "pg_lsn" } + } + columns { + name: "local_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_origin_status" + } + type { name: "pg_lsn" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + columns { + name: "slot_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "name" } + } + columns { + name: "plugin" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "name" } + } + columns { + name: "slot_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "text" } + } + columns { + name: "datoid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "oid" } + } + columns { + name: "database" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "name" } + } + columns { + name: "temporary" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "bool" } + } + columns { + name: "active" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "bool" } + } + columns { + name: "active_pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "int4" } + } + columns { + name: "xmin" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "xid" } + } + columns { + name: "catalog_xmin" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "xid" } + } + columns { + name: "restart_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "pg_lsn" } + } + columns { + name: "confirmed_flush_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "pg_lsn" } + } + columns { + name: "wal_status" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "text" } + } + columns { + name: "safe_wal_size" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "int8" } + } + columns { + name: "two_phase" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_replication_slots" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "oid" } + } + columns { + name: "rulename" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "name" } + } + columns { + name: "ev_class" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "oid" } + } + columns { + name: "ev_type" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "char" } + } + columns { + name: "ev_enabled" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "char" } + } + columns { + name: "is_instead" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "bool" } + } + columns { + name: "ev_qual" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "pg_node_tree" } + } + columns { + name: "ev_action" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rewrite" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" } + columns { + name: "rolname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "name" } + } + columns { + name: "rolsuper" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolinherit" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolcreaterole" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolcreatedb" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolcanlogin" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolreplication" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolconnlimit" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "int4" } + } + columns { + name: "rolpassword" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "text" } + } + columns { + name: "rolvaliduntil" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "timestamptz" } + } + columns { + name: "rolbypassrls" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "bool" } + } + columns { + name: "rolconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "_text" } + } + columns { + name: "oid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_roles" + } + type { name: "oid" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" + } + type { name: "name" } + } + columns { + name: "rulename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" + } + type { name: "name" } + } + columns { + name: "definition" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_rules" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "int4" } + } + columns { + name: "provider" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "text" } + } + columns { + name: "label" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabel" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + columns { + name: "objoid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "oid" } + } + columns { + name: "classoid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "oid" } + } + columns { + name: "objsubid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "int4" } + } + columns { + name: "objtype" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "text" } + } + columns { + name: "objnamespace" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "oid" } + } + columns { + name: "objname" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "text" } + } + columns { + name: "provider" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "text" } + } + columns { + name: "label" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_seclabels" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "tid" } + } + columns { + name: "seqrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "oid" } + } + columns { + name: "seqtypid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "oid" } + } + columns { + name: "seqstart" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqincrement" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqmax" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqmin" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqcache" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "int8" } + } + columns { + name: "seqcycle" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequence" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "name" } + } + columns { + name: "sequencename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "name" } + } + columns { + name: "sequenceowner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "name" } + } + columns { + name: "data_type" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "regtype" } + } + columns { + name: "start_value" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "min_value" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "max_value" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "increment_by" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "cycle" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "bool" } + } + columns { + name: "cache_size" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + columns { + name: "last_value" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_sequences" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "setting" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "unit" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "category" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "short_desc" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "extra_desc" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "context" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "vartype" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "source" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "min_val" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "max_val" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "enumvals" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "_text" } + } + columns { + name: "boot_val" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "reset_val" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "sourcefile" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "text" } + } + columns { + name: "sourceline" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "int4" } + } + columns { + name: "pending_restart" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_settings" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "name" } + } + columns { + name: "usesysid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "oid" } + } + columns { + name: "usecreatedb" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "bool" } + } + columns { + name: "usesuper" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "bool" } + } + columns { + name: "userepl" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "bool" } + } + columns { + name: "usebypassrls" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "bool" } + } + columns { + name: "passwd" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "text" } + } + columns { + name: "valuntil" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "timestamptz" } + } + columns { + name: "useconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shadow" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "tid" } + } + columns { + name: "dbid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "classid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "objid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "objsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "int4" } + } + columns { + name: "refclassid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "refobjid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "oid" } + } + columns { + name: "deptype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdepend" + } + type { name: "char" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "oid" } + } + columns { + name: "description" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shdescription" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + type { name: "text" } + } + columns { + name: "off" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + type { name: "int8" } + } + columns { + name: "size" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + type { name: "int8" } + } + columns { + name: "allocated_size" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_shmem_allocations" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "tid" } + } + columns { + name: "objoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "oid" } + } + columns { + name: "classoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "oid" } + } + columns { + name: "provider" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "text" } + } + columns { + name: "label" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_shseclabel" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "name" } + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "int4" } + } + columns { + name: "leader_pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "int4" } + } + columns { + name: "usesysid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "oid" } + } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "name" } + } + columns { + name: "application_name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "client_addr" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "inet" } + } + columns { + name: "client_hostname" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "client_port" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "int4" } + } + columns { + name: "backend_start" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "timestamptz" } + } + columns { + name: "xact_start" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "timestamptz" } + } + columns { + name: "query_start" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "timestamptz" } + } + columns { + name: "state_change" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "timestamptz" } + } + columns { + name: "wait_event_type" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "wait_event" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "state" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "backend_xid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "xid" } + } + columns { + name: "backend_xmin" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "xid" } + } + columns { + name: "query_id" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "int8" } + } + columns { + name: "query" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + columns { + name: "backend_type" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_activity" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "name" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_live_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_dead_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_mod_since_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_ins_since_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "last_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autovacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autoanalyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "timestamptz" } + } + columns { + name: "vacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "autovacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "analyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + columns { + name: "autoanalyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_all_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + columns { + name: "archived_count" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "int8" } + } + columns { + name: "last_archived_wal" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "text" } + } + columns { + name: "last_archived_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "timestamptz" } + } + columns { + name: "failed_count" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "int8" } + } + columns { + name: "last_failed_wal" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "text" } + } + columns { + name: "last_failed_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "timestamptz" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_archiver" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + columns { + name: "checkpoints_timed" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "checkpoints_req" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "checkpoint_write_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "float8" } + } + columns { + name: "checkpoint_sync_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "float8" } + } + columns { + name: "buffers_checkpoint" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "buffers_clean" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "maxwritten_clean" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "buffers_backend" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "buffers_backend_fsync" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "buffers_alloc" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_bgwriter" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "name" } + } + columns { + name: "numbackends" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int4" } + } + columns { + name: "xact_commit" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "xact_rollback" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_returned" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_fetched" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_inserted" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_updated" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "tup_deleted" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "conflicts" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "temp_files" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "temp_bytes" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "deadlocks" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "checksum_failures" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "checksum_last_failure" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "timestamptz" } + } + columns { + name: "blk_read_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "blk_write_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "session_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "active_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "idle_in_transaction_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "float8" } + } + columns { + name: "sessions" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "sessions_abandoned" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "sessions_fatal" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "sessions_killed" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_database" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "name" } + } + columns { + name: "confl_tablespace" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + columns { + name: "confl_lock" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + columns { + name: "confl_snapshot" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + columns { + name: "confl_bufferpin" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + columns { + name: "confl_deadlock" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_database_conflicts" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + type { name: "int4" } + } + columns { + name: "gss_authenticated" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + type { name: "bool" } + } + columns { + name: "principal" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + type { name: "text" } + } + columns { + name: "encrypted" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_gssapi" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "oid" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "text" } + } + columns { + name: "sample_blks_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "sample_blks_scanned" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "ext_stats_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "ext_stats_computed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "child_tables_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "child_tables_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "int8" } + } + columns { + name: "current_child_table_relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_analyze" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int4" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "text" } + } + columns { + name: "backup_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int8" } + } + columns { + name: "backup_streamed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int8" } + } + columns { + name: "tablespaces_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int8" } + } + columns { + name: "tablespaces_streamed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_basebackup" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "oid" } + } + columns { + name: "command" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "text" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "text" } + } + columns { + name: "cluster_index_relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "oid" } + } + columns { + name: "heap_tuples_scanned" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + columns { + name: "heap_tuples_written" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + columns { + name: "heap_blks_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + columns { + name: "heap_blks_scanned" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + columns { + name: "index_rebuild_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_cluster" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "oid" } + } + columns { + name: "command" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "text" } + } + columns { + name: "type" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "text" } + } + columns { + name: "bytes_processed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int8" } + } + columns { + name: "bytes_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int8" } + } + columns { + name: "tuples_processed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int8" } + } + columns { + name: "tuples_excluded" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_copy" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "oid" } + } + columns { + name: "index_relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "oid" } + } + columns { + name: "command" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "text" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "text" } + } + columns { + name: "lockers_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "lockers_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "current_locker_pid" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "blocks_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "blocks_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "tuples_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "tuples_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "partitions_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + columns { + name: "partitions_done" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_create_index" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int4" } + } + columns { + name: "datid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "oid" } + } + columns { + name: "datname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "name" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "oid" } + } + columns { + name: "phase" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "text" } + } + columns { + name: "heap_blks_total" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "heap_blks_scanned" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "heap_blks_vacuumed" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "index_vacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "max_dead_tuples" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + columns { + name: "num_dead_tuples" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_progress_vacuum" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "timestamptz" } + } + columns { + name: "prefetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "skip_init" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "skip_new" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "skip_fpw" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "skip_rep" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int8" } + } + columns { + name: "wal_distance" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int4" } + } + columns { + name: "block_distance" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int4" } + } + columns { + name: "io_depth" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_recovery_prefetch" + } + type { name: "int4" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "int4" } + } + columns { + name: "usesysid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "oid" } + } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "name" } + } + columns { + name: "application_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "text" } + } + columns { + name: "client_addr" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "inet" } + } + columns { + name: "client_hostname" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "text" } + } + columns { + name: "client_port" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "int4" } + } + columns { + name: "backend_start" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "timestamptz" } + } + columns { + name: "backend_xmin" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "xid" } + } + columns { + name: "state" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "text" } + } + columns { + name: "sent_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "pg_lsn" } + } + columns { + name: "write_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "pg_lsn" } + } + columns { + name: "flush_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "pg_lsn" } + } + columns { + name: "replay_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "pg_lsn" } + } + columns { + name: "write_lag" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "interval" } + } + columns { + name: "flush_lag" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "interval" } + } + columns { + name: "replay_lag" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "interval" } + } + columns { + name: "sync_priority" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "int4" } + } + columns { + name: "sync_state" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "text" } + } + columns { + name: "reply_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + columns { + name: "slot_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "text" } + } + columns { + name: "spill_txns" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "spill_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "spill_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "stream_txns" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "stream_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "stream_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "total_txns" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "total_bytes" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_replication_slots" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "text" } + } + columns { + name: "blks_zeroed" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "blks_written" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "blks_exists" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "flushes" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "truncates" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_slru" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "int4" } + } + columns { + name: "ssl" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "bool" } + } + columns { + name: "version" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "text" } + } + columns { + name: "cipher" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "text" } + } + columns { + name: "bits" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "int4" } + } + columns { + name: "client_dn" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "text" } + } + columns { + name: "client_serial" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "numeric" } + } + columns { + name: "issuer_dn" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_ssl" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + columns { + name: "subid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "oid" } + } + columns { + name: "subname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "name" } + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "int4" } + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "oid" } + } + columns { + name: "received_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "pg_lsn" } + } + columns { + name: "last_msg_send_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "timestamptz" } + } + columns { + name: "last_msg_receipt_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "timestamptz" } + } + columns { + name: "latest_end_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "pg_lsn" } + } + columns { + name: "latest_end_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + columns { + name: "subid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "oid" } + } + columns { + name: "subname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "name" } + } + columns { + name: "apply_error_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "int8" } + } + columns { + name: "sync_error_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "int8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_subscription_stats" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "name" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_live_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_dead_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_mod_since_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_ins_since_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "last_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autovacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autoanalyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "timestamptz" } + } + columns { + name: "vacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "autovacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "analyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + columns { + name: "autoanalyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_sys_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + columns { + name: "funcid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "name" } + } + columns { + name: "funcname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "name" } + } + columns { + name: "calls" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "int8" } + } + columns { + name: "total_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "float8" } + } + columns { + name: "self_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_functions" + } + type { name: "float8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "name" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_live_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_dead_tup" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_mod_since_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_ins_since_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "last_vacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autovacuum" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_analyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "timestamptz" } + } + columns { + name: "last_autoanalyze" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "timestamptz" } + } + columns { + name: "vacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "autovacuum_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "analyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + columns { + name: "autoanalyze_count" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_user_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + columns { + name: "wal_records" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_fpi" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_bytes" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "numeric" } + } + columns { + name: "wal_buffers_full" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_write" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_sync" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "int8" } + } + columns { + name: "wal_write_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "float8" } + } + columns { + name: "wal_sync_time" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "float8" } + } + columns { + name: "stats_reset" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stat_wal" + } + type { name: "timestamptz" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + columns { + name: "pid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "int4" } + } + columns { + name: "status" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "text" } + } + columns { + name: "receive_start_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "pg_lsn" } + } + columns { + name: "receive_start_tli" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "int4" } + } + columns { + name: "written_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "pg_lsn" } + } + columns { + name: "flushed_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "pg_lsn" } + } + columns { + name: "received_tli" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "int4" } + } + columns { + name: "last_msg_send_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "timestamptz" } + } + columns { + name: "last_msg_receipt_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "timestamptz" } + } + columns { + name: "latest_end_lsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "pg_lsn" } + } + columns { + name: "latest_end_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "timestamptz" } + } + columns { + name: "slot_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "text" } + } + columns { + name: "sender_host" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "text" } + } + columns { + name: "sender_port" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "int4" } + } + columns { + name: "conninfo" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_wal_receiver" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_all_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_sys_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + columns { + name: "funcid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "name" } + } + columns { + name: "funcname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "name" } + } + columns { + name: "calls" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "int8" } + } + columns { + name: "total_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "float8" } + } + columns { + name: "self_time" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_functions" + } + type { name: "float8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "name" } + } + columns { + name: "seq_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "seq_tup_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_scan" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_tup_fetch" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_ins" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_del" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + columns { + name: "n_tup_hot_upd" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stat_xact_user_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "name" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "name" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_sequences" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "name" } + } + columns { + name: "heap_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "heap_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_all_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "name" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "name" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_sequences" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "name" } + } + columns { + name: "heap_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "heap_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_sys_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "oid" } + } + columns { + name: "indexrelid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "name" } + } + columns { + name: "indexrelname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "name" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_indexes" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "name" } + } + columns { + name: "blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "int8" } + } + columns { + name: "blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_sequences" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + columns { + name: "relid" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "oid" } + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "name" } + } + columns { + name: "heap_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "heap_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "idx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "toast_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_read" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + columns { + name: "tidx_blks_hit" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statio_user_tables" + } + type { name: "int8" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "tid" } + } + columns { + name: "starelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staattnum" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stainherit" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "bool" } + } + columns { + name: "stanullfrac" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "float4" } + } + columns { + name: "stawidth" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int4" } + } + columns { + name: "stadistinct" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "float4" } + } + columns { + name: "stakind1" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stakind2" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stakind3" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stakind4" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "stakind5" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "int2" } + } + columns { + name: "staop1" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staop2" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staop3" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staop4" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "staop5" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll1" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll2" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll3" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll4" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stacoll5" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "oid" } + } + columns { + name: "stanumbers1" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stanumbers2" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stanumbers3" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stanumbers4" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stanumbers5" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "_float4" } + } + columns { + name: "stavalues1" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + columns { + name: "stavalues2" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + columns { + name: "stavalues3" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + columns { + name: "stavalues4" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + columns { + name: "stavalues5" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic" + } + type { name: "anyarray" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "stxrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "stxname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "name" } + } + columns { + name: "stxnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "stxowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "oid" } + } + columns { + name: "stxstattarget" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "int4" } + } + columns { + name: "stxkeys" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "int2vector" } + } + columns { + name: "stxkind" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "_char" } + } + columns { + name: "stxexprs" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_statistic_ext" + } + type { name: "pg_node_tree" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "tid" } + } + columns { + name: "stxoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "oid" } + } + columns { + name: "stxdinherit" + not_null: true + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "bool" } + } + columns { + name: "stxdndistinct" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "pg_ndistinct" } + } + columns { + name: "stxddependencies" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "pg_dependencies" } + } + columns { + name: "stxdmcv" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "pg_mcv_list" } + } + columns { + name: "stxdexpr" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_statistic_ext_data" + } + type { name: "_pg_statistic" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "name" } + } + columns { + name: "attname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "name" } + } + columns { + name: "inherited" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "bool" } + } + columns { + name: "null_frac" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "float4" } + } + columns { + name: "avg_width" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "int4" } + } + columns { + name: "n_distinct" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "float4" } + } + columns { + name: "most_common_vals" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "anyarray" } + } + columns { + name: "most_common_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "_float4" } + } + columns { + name: "histogram_bounds" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "anyarray" } + } + columns { + name: "correlation" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "float4" } + } + columns { + name: "most_common_elems" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "anyarray" } + } + columns { + name: "most_common_elem_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "_float4" } + } + columns { + name: "elem_count_histogram" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats" + } + type { name: "_float4" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "statistics_schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "statistics_name" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "statistics_owner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "name" } + } + columns { + name: "attnames" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_name" } + } + columns { + name: "exprs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_text" } + } + columns { + name: "kinds" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_char" } + } + columns { + name: "inherited" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "bool" } + } + columns { + name: "n_distinct" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "pg_ndistinct" } + } + columns { + name: "dependencies" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "pg_dependencies" } + } + columns { + name: "most_common_vals" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_text" } + } + columns { + name: "most_common_val_nulls" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_bool" } + } + columns { + name: "most_common_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_float8" } + } + columns { + name: "most_common_base_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_stats_ext" + } + type { name: "_float8" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "statistics_schemaname" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "statistics_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "statistics_owner" + length: 64 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "name" } + } + columns { + name: "expr" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "text" } + } + columns { + name: "inherited" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "bool" } + } + columns { + name: "null_frac" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "float4" } + } + columns { + name: "avg_width" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "int4" } + } + columns { + name: "n_distinct" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "float4" } + } + columns { + name: "most_common_vals" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "anyarray" } + } + columns { + name: "most_common_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "_float4" } + } + columns { + name: "histogram_bounds" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "anyarray" } + } + columns { + name: "correlation" + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "float4" } + } + columns { + name: "most_common_elems" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "anyarray" } + } + columns { + name: "most_common_elem_freqs" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "_float4" } + } + columns { + name: "elem_count_histogram" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_stats_ext_exprs" + } + type { name: "_float4" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "oid" } + } + columns { + name: "subdbid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "oid" } + } + columns { + name: "subskiplsn" + not_null: true + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "pg_lsn" } + } + columns { + name: "subname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "name" } + } + columns { + name: "subowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "oid" } + } + columns { + name: "subenabled" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "bool" } + } + columns { + name: "subbinary" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "bool" } + } + columns { + name: "substream" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "bool" } + } + columns { + name: "subtwophasestate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "char" } + } + columns { + name: "subdisableonerr" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "bool" } + } + columns { + name: "subconninfo" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "text" } + } + columns { + name: "subslotname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "name" } + } + columns { + name: "subsynccommit" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "text" } + } + columns { + name: "subpublications" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_subscription" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "tid" } + } + columns { + name: "srsubid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "oid" } + } + columns { + name: "srrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "oid" } + } + columns { + name: "srsubstate" + not_null: true + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "char" } + } + columns { + name: "srsublsn" + length: 8 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_subscription_rel" + } + type { name: "pg_lsn" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "name" } + } + columns { + name: "tablename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "name" } + } + columns { + name: "tableowner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "name" } + } + columns { + name: "tablespace" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "name" } + } + columns { + name: "hasindexes" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "bool" } + } + columns { + name: "hasrules" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "bool" } + } + columns { + name: "hastriggers" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "bool" } + } + columns { + name: "rowsecurity" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tables" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "oid" } + } + columns { + name: "spcname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "name" } + } + columns { + name: "spcowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "oid" } + } + columns { + name: "spcacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "_aclitem" } + } + columns { + name: "spcoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_tablespace" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_abbrevs" + } + columns { + name: "abbrev" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_abbrevs" + } + type { name: "text" } + } + columns { + name: "utc_offset" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_abbrevs" + } + type { name: "interval" } + } + columns { + name: "is_dst" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_abbrevs" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + columns { + name: "name" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + type { name: "text" } + } + columns { + name: "abbrev" + length: -1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + type { name: "text" } + } + columns { + name: "utc_offset" + length: 16 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + type { name: "interval" } + } + columns { + name: "is_dst" + length: 1 + table { + catalog: "pg_catalog" + schema: "pg_catalog" + name: "pg_timezone_names" + } + type { name: "bool" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "oid" } + } + columns { + name: "trftype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "oid" } + } + columns { + name: "trflang" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "oid" } + } + columns { + name: "trffromsql" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "regproc" } + } + columns { + name: "trftosql" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_transform" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgparentid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "name" } + } + columns { + name: "tgfoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgtype" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "int2" } + } + columns { + name: "tgenabled" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "char" } + } + columns { + name: "tgisinternal" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "bool" } + } + columns { + name: "tgconstrrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgconstrindid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgconstraint" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "oid" } + } + columns { + name: "tgdeferrable" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "bool" } + } + columns { + name: "tginitdeferred" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "bool" } + } + columns { + name: "tgnargs" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "int2" } + } + columns { + name: "tgattr" + not_null: true + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "int2vector" } + } + columns { + name: "tgargs" + not_null: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "bytea" } + } + columns { + name: "tgqual" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "pg_node_tree" } + } + columns { + name: "tgoldtable" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "name" } + } + columns { + name: "tgnewtable" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_trigger" + } + type { name: "name" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + columns { + name: "cfgname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "name" } + } + columns { + name: "cfgnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + columns { + name: "cfgowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + columns { + name: "cfgparser" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "tid" } + } + columns { + name: "mapcfg" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "oid" } + } + columns { + name: "maptokentype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "int4" } + } + columns { + name: "mapseqno" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "int4" } + } + columns { + name: "mapdict" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_config_map" + } + type { name: "oid" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "dictname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "name" } + } + columns { + name: "dictnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "dictowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "dicttemplate" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "oid" } + } + columns { + name: "dictinitoption" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_dict" + } + type { name: "text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "oid" } + } + columns { + name: "prsname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "name" } + } + columns { + name: "prsnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "oid" } + } + columns { + name: "prsstart" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + columns { + name: "prstoken" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + columns { + name: "prsend" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + columns { + name: "prsheadline" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + columns { + name: "prslextype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_parser" + } + type { name: "regproc" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "oid" } + } + columns { + name: "tmplname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "name" } + } + columns { + name: "tmplnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "oid" } + } + columns { + name: "tmplinit" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "regproc" } + } + columns { + name: "tmpllexize" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_ts_template" + } + type { name: "regproc" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typname" + not_null: true + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "name" } + } + columns { + name: "typnamespace" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typowner" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typlen" + not_null: true + length: 2 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "int2" } + } + columns { + name: "typbyval" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "bool" } + } + columns { + name: "typtype" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typcategory" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typispreferred" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "bool" } + } + columns { + name: "typisdefined" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "bool" } + } + columns { + name: "typdelim" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typrelid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typsubscript" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typelem" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typarray" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typinput" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typoutput" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typreceive" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typsend" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typmodin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typmodout" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typanalyze" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "regproc" } + } + columns { + name: "typalign" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typstorage" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "char" } + } + columns { + name: "typnotnull" + not_null: true + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "bool" } + } + columns { + name: "typbasetype" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typtypmod" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "int4" } + } + columns { + name: "typndims" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "int4" } + } + columns { + name: "typcollation" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "oid" } + } + columns { + name: "typdefaultbin" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "pg_node_tree" } + } + columns { + name: "typdefault" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "text" } + } + columns { + name: "typacl" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_type" + } + type { name: "_aclitem" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "name" } + } + columns { + name: "usesysid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "oid" } + } + columns { + name: "usecreatedb" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "bool" } + } + columns { + name: "usesuper" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "bool" } + } + columns { + name: "userepl" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "bool" } + } + columns { + name: "usebypassrls" + length: 1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "bool" } + } + columns { + name: "passwd" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "text" } + } + columns { + name: "valuntil" + length: 8 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "timestamptz" } + } + columns { + name: "useconfig" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "tid" } + } + columns { + name: "oid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "oid" } + } + columns { + name: "umuser" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "oid" } + } + columns { + name: "umserver" + not_null: true + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "oid" } + } + columns { + name: "umoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mapping" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + columns { + name: "umid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "srvid" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "srvname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "name" } + } + columns { + name: "umuser" + length: 4 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "usename" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "name" } + } + columns { + name: "umoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_user_mappings" + } + type { name: "_text" } + } + } + tables { + rel { catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" } + columns { + name: "schemaname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" + } + type { name: "name" } + } + columns { + name: "viewname" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" + } + type { name: "name" } + } + columns { + name: "viewowner" + length: 64 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" + } + type { name: "name" } + } + columns { + name: "definition" + length: -1 + table { + catalog: "pg_catalog" schema: "pg_catalog" name: "pg_views" + } + type { name: "text" } + } + } + } + schemas { + name: "information_schema" + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + columns { + name: "oid" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "oid" } + } + columns { + name: "fdwowner" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "oid" } + } + columns { + name: "fdwoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "_text" } + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_language" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_data_wrappers" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + columns { + name: "oid" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "oid" } + } + columns { + name: "srvoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "_text" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "character_data" } + } + columns { + name: "foreign_server_version" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "character_data" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_servers" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + columns { + name: "nspname" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + type { name: "name" } + } + columns { + name: "relname" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + type { name: "name" } + } + columns { + name: "attname" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + type { name: "name" } + } + columns { + name: "attfdwoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_table_columns" + } + type { name: "_text" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + columns { + name: "foreign_table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "ftoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "_text" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_foreign_tables" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + columns { + name: "oid" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "umoptions" + is_array: true + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "_text" } + } + columns { + name: "umuser" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "oid" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "srvowner" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "_pg_user_mappings" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "administrable_role_authorizations" + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "administrable_role_authorizations" + } + type { name: "sql_identifier" } + } + columns { + name: "role_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "administrable_role_authorizations" + } + type { name: "sql_identifier" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "administrable_role_authorizations" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "applicable_roles" + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "applicable_roles" + } + type { name: "sql_identifier" } + } + columns { + name: "role_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "applicable_roles" + } + type { name: "sql_identifier" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "applicable_roles" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "attribute_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "ordinal_position" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "attribute_default" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "character_data" } + } + columns { + name: "is_nullable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "yes_or_no" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "attribute_udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "attribute_udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "attribute_udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "sql_identifier" } + } + columns { + name: "is_derived_reference_attribute" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "attributes" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "character_repertoire" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "form_of_use" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "default_collate_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "default_collate_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + columns { + name: "default_collate_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "character_sets" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraint_routine_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "check_clause" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "check_constraints" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collation_character_set_applicability" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + type { name: "sql_identifier" } + } + columns { + name: "pad_attribute" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "collations" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "dependent_column" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_column_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_domain_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "column_udt_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "ordinal_position" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "column_default" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "is_nullable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "sql_identifier" } + } + columns { + name: "is_self_referencing" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + columns { + name: "is_identity" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + columns { + name: "identity_generation" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_start" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_increment" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_maximum" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_minimum" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "identity_cycle" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + columns { + name: "is_generated" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "generation_expression" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "character_data" } + } + columns { + name: "is_updatable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "columns" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_column_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "constraint_table_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + columns { + name: "object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "character_data" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "data_type_privileges" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "is_deferrable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "yes_or_no" } + } + columns { + name: "initially_deferred" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_constraints" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "domain_udt_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + columns { + name: "domain_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "domain_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "domain_default" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "character_data" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "domains" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + columns { + name: "object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "object_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "object_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "character_data" } + } + columns { + name: "collection_type_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "domain_default" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "character_data" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "element_types" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "enabled_roles" + } + columns { + name: "role_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "enabled_roles" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrapper_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "sql_identifier" } + } + columns { + name: "library_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "character_data" } + } + columns { + name: "foreign_data_wrapper_language" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_data_wrappers" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_server_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_data_wrapper_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "character_data" } + } + columns { + name: "foreign_server_version" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "character_data" } + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_servers" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + columns { + name: "foreign_table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_table_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + columns { + name: "foreign_table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "foreign_tables" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "information_schema_catalog_name" + } + columns { + name: "catalog_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "information_schema_catalog_name" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "ordinal_position" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "cardinal_number" } + } + columns { + name: "position_in_unique_constraint" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "key_column_usage" + } + type { name: "cardinal_number" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "ordinal_position" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "parameter_mode" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "character_data" } + } + columns { + name: "is_result" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "yes_or_no" } + } + columns { + name: "as_locator" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "yes_or_no" } + } + columns { + name: "parameter_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "sql_identifier" } + } + columns { + name: "parameter_default" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "parameters" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "unique_constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "unique_constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "unique_constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "match_option" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "character_data" } + } + columns { + name: "update_rule" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "character_data" } + } + columns { + name: "delete_rule" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "referential_constraints" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_column_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_routine_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "yes_or_no" } + } + columns { + name: "with_hierarchy" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_table_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_udt_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "object_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "sql_identifier" } + } + columns { + name: "object_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "character_data" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "role_usage_grants" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_column_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_routine_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_sequence_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "routine_table_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "module_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "module_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "module_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "type_udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "type_udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "type_udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "scope_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "routine_body" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "routine_definition" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "external_name" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "external_language" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "parameter_style" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "is_deterministic" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "sql_data_access" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "is_null_call" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "sql_path" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "schema_level_routine" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "max_dynamic_result_sets" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "is_user_defined_cast" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "is_implicitly_invocable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "security_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "to_sql_specific_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "to_sql_specific_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "to_sql_specific_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "as_locator" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "created" + length: 8 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "time_stamp" } + } + columns { + name: "last_altered" + length: 8 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "time_stamp" } + } + columns { + name: "new_savepoint_level" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "is_udt_dependent" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "result_cast_from_data_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "result_cast_as_locator" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "yes_or_no" } + } + columns { + name: "result_cast_char_max_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_char_octet_length" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_char_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_char_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_char_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_collation_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_collation_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_collation_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_numeric_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_numeric_scale" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_datetime_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_interval_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "character_data" } + } + columns { + name: "result_cast_interval_precision" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_type_udt_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_type_udt_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_type_udt_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_scope_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_scope_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_scope_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + columns { + name: "result_cast_maximum_cardinality" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "cardinal_number" } + } + columns { + name: "result_cast_dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "routines" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + columns { + name: "catalog_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "schema_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "schema_owner" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "default_character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "default_character_set_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "default_character_set_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "sql_identifier" } + } + columns { + name: "sql_path" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "schemata" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + columns { + name: "sequence_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "sql_identifier" } + } + columns { + name: "sequence_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "sql_identifier" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "cardinal_number" } + } + columns { + name: "start_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "minimum_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "maximum_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "increment" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "character_data" } + } + columns { + name: "cycle_option" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sequences" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "tid" } + } + columns { + name: "feature_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "feature_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "sub_feature_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "sub_feature_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "is_supported" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "yes_or_no" } + } + columns { + name: "is_verified_by" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + columns { + name: "comments" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_features" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "tid" } + } + columns { + name: "implementation_info_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "character_data" } + } + columns { + name: "implementation_info_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "character_data" } + } + columns { + name: "integer_value" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "cardinal_number" } + } + columns { + name: "character_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "character_data" } + } + columns { + name: "comments" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_implementation_info" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "tid" } + } + columns { + name: "feature_id" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "character_data" } + } + columns { + name: "feature_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "character_data" } + } + columns { + name: "is_supported" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "yes_or_no" } + } + columns { + name: "is_verified_by" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "character_data" } + } + columns { + name: "comments" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_parts" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + columns { + name: "tableoid" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "oid" } + } + columns { + name: "cmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "cid" } + } + columns { + name: "xmax" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "xid" } + } + columns { + name: "cmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "cid" } + } + columns { + name: "xmin" + not_null: true + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "xid" } + } + columns { + name: "ctid" + not_null: true + length: 6 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "tid" } + } + columns { + name: "sizing_id" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "cardinal_number" } + } + columns { + name: "sizing_name" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "character_data" } + } + columns { + name: "supported_value" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "cardinal_number" } + } + columns { + name: "comments" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "sql_sizing" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + columns { + name: "constraint_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "sql_identifier" } + } + columns { + name: "constraint_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "character_data" } + } + columns { + name: "is_deferrable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "yes_or_no" } + } + columns { + name: "initially_deferred" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "yes_or_no" } + } + columns { + name: "enforced" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "yes_or_no" } + } + columns { + name: "nulls_distinct" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_constraints" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "yes_or_no" } + } + columns { + name: "with_hierarchy" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "table_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "table_type" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "character_data" } + } + columns { + name: "self_referencing_column_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "reference_generation" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "character_data" } + } + columns { + name: "user_defined_type_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "sql_identifier" } + } + columns { + name: "is_insertable_into" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "yes_or_no" } + } + columns { + name: "is_typed" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "yes_or_no" } + } + columns { + name: "commit_action" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "tables" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "group_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "sql_identifier" } + } + columns { + name: "transform_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "transforms" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + columns { + name: "trigger_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "trigger_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "trigger_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_table" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_column" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "triggered_update_columns" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + columns { + name: "trigger_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "trigger_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "trigger_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "event_manipulation" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "event_object_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "event_object_table" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "action_order" + length: 4 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "cardinal_number" } + } + columns { + name: "action_condition" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "action_statement" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "action_orientation" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "action_timing" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "character_data" } + } + columns { + name: "action_reference_old_table" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "action_reference_new_table" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "action_reference_old_row" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "action_reference_new_row" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "sql_identifier" } + } + columns { + name: "created" + length: 8 + table { + catalog: "pg_catalog" schema: "information_schema" name: "triggers" + } + type { name: "time_stamp" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "udt_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "udt_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + columns { + name: "grantor" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "grantee" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "sql_identifier" } + } + columns { + name: "object_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "character_data" } + } + columns { + name: "privilege_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "character_data" } + } + columns { + name: "is_grantable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "usage_privileges" + } + type { name: "yes_or_no" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + columns { + name: "user_defined_type_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "user_defined_type_category" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "is_instantiable" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "yes_or_no" } + } + columns { + name: "is_final" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "yes_or_no" } + } + columns { + name: "ordering_form" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "ordering_category" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "ordering_routine_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "ordering_routine_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "ordering_routine_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "reference_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "data_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "character_maximum_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "character_octet_length" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "character_set_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "character_set_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "collation_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "numeric_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_precision_radix" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "numeric_scale" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "datetime_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "interval_type" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "character_data" } + } + columns { + name: "interval_precision" + length: 4 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "cardinal_number" } + } + columns { + name: "source_dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + columns { + name: "ref_dtd_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_defined_types" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "sql_identifier" } + } + columns { + name: "option_value" + length: -1 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mapping_options" + } + type { name: "character_data" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mappings" + } + columns { + name: "authorization_identifier" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mappings" + } + type { name: "sql_identifier" } + } + columns { + name: "foreign_server_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "user_mappings" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + columns { + name: "view_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "view_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "view_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "column_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_column_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "specific_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_routine_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + columns { + name: "view_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "view_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "view_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" + schema: "information_schema" + name: "view_table_usage" + } + type { name: "sql_identifier" } + } + } + tables { + rel { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + columns { + name: "table_catalog" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "sql_identifier" } + } + columns { + name: "table_schema" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "sql_identifier" } + } + columns { + name: "table_name" + length: 64 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "sql_identifier" } + } + columns { + name: "view_definition" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "character_data" } + } + columns { + name: "check_option" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "character_data" } + } + columns { + name: "is_updatable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + columns { + name: "is_insertable_into" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + columns { + name: "is_trigger_updatable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + columns { + name: "is_trigger_deletable" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + columns { + name: "is_trigger_insertable_into" + length: -1 + table { + catalog: "pg_catalog" schema: "information_schema" name: "views" + } + type { name: "yes_or_no" } + } + } + } +} +queries { + text: "SELECT id, organization_id, display_name, login_name, password_bcrypt, is_deleted, created_at, updated_at FROM logins WHERE id = $1 AND NOT is_deleted" + name: "getLoginById" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "login_name" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_name" + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "serial" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, organization_id, display_name, login_name, password_bcrypt, is_deleted, created_at, updated_at FROM logins WHERE login_name = $1 AND NOT is_deleted" + name: "getLoginByName" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "login_name" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_name" + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "login_name" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_name" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT logins.id, logins.organization_id, logins.display_name, logins.login_name, logins.password_bcrypt, logins.is_deleted, logins.created_at, logins.updated_at, organizations.id, organizations.display_name, organizations.created_at, organizations.updated_at\n FROM logins\n JOIN organization_logins ON logins.id = organization_logins.login_id\n JOIN organizations ON organizations.id = organization_logins.organization_id\n WHERE\n logins.id = $1 AND NOT logins.is_deleted" + name: "getLoginOrganizations" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "login_name" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_name" + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "created_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "serial" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, display_name, created_at, updated_at FROM organizations LIMIT 100" + name: "getOrganizations" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "created_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + filename: "queries.sql" +} +queries { + text: "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams WHERE organization_id = $1 AND NOT is_deleted ORDER BY display_name ASC" + name: "getTeams" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "pg_catalog.int4" } + original_name: "organization_id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams WHERE organization_id = $1 AND id = $2 AND NOT is_deleted" + name: "getTeamById" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "pg_catalog.int4" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "serial" } + original_name: "id" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT teams.id, organization_id, teams.display_name, invitation_code, is_deleted, teams.created_at, teams.updated_at, organizations.id, organizations.display_name, organizations.created_at, organizations.updated_at FROM teams JOIN organizations ON teams.organization_id = organizations.id WHERE invitation_code = $1 AND NOT is_deleted" + name: "getTeamByInvitationCode" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "id" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "organizations" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "created_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "organizations" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + } + filename: "queries.sql" +} +queries { + text: "SELECT id, organization_id, display_name, login_name, password_bcrypt, is_deleted, logins.created_at, logins.updated_at, team_id, login_id, team_members.created_at, team_members.updated_at FROM logins JOIN team_members ON logins.id = team_members.login_id WHERE team_id = $1" + name: "getTeamMembers" + cmd: ":many" + columns { + name: "id" + not_null: true + length: -1 + table { name: "logins" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "login_name" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "login_name" + } + columns { + name: "password_bcrypt" + not_null: true + length: -1 + table { name: "logins" } + type { name: "text" } + original_name: "password_bcrypt" + } + columns { + name: "is_deleted" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "logins" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + columns { + name: "team_id" + not_null: true + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "int4" } + original_name: "team_id" + } + columns { + name: "login_id" + not_null: true + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "int4" } + original_name: "login_id" + } + columns { + name: "created_at" + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "team_members" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "team_id" + not_null: true + length: -1 + table { name: "team_members" } + type { name: "pg_catalog.int4" } + original_name: "team_id" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO team_members (team_id, login_id) VALUES ($1, $2) ON CONFLICT (team_id, login_id) DO NOTHING" + name: "insertTeamMember" + cmd: ":exec" + params { + number: 1 + column { + name: "team_id" + not_null: true + length: -1 + table { schema: "public" name: "team_members" } + type { name: "pg_catalog.int4" } + original_name: "team_id" + } + } + params { + number: 2 + column { + name: "login_id" + not_null: true + length: -1 + table { schema: "public" name: "team_members" } + type { name: "pg_catalog.int4" } + original_name: "login_id" + } + } + filename: "queries.sql" + insert_into_table { name: "team_members" } +} +queries { + text: "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams WHERE organization_id = $1 AND display_name = $2" + name: "getTeamByName" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "pg_catalog.int4" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + } + filename: "queries.sql" +} +queries { + text: "INSERT INTO teams (organization_id, display_name, invitation_code, is_deleted) VALUES ($1, $2, $3, false) RETURNING id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at" + name: "insertTeam" + cmd: ":one" + columns { + name: "id" + not_null: true + length: -1 + table { name: "teams" } + type { name: "serial" } + original_name: "id" + } + columns { + name: "organization_id" + not_null: true + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "int4" } + original_name: "organization_id" + } + columns { + name: "display_name" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "display_name" + } + columns { + name: "invitation_code" + not_null: true + length: -1 + table { name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + columns { + name: "is_deleted" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "bool" } + original_name: "is_deleted" + } + columns { + name: "created_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "created_at" + } + columns { + name: "updated_at" + length: -1 + table { name: "teams" } + type { schema: "pg_catalog" name: "timestamptz" } + original_name: "updated_at" + } + params { + number: 1 + column { + name: "organization_id" + not_null: true + length: -1 + table { schema: "public" name: "teams" } + type { name: "pg_catalog.int4" } + original_name: "organization_id" + } + } + params { + number: 2 + column { + name: "display_name" + not_null: true + length: -1 + table { schema: "public" name: "teams" } + type { name: "text" } + original_name: "display_name" + } + } + params { + number: 3 + column { + name: "invitation_code" + not_null: true + length: -1 + table { schema: "public" name: "teams" } + type { name: "text" } + original_name: "invitation_code" + } + } + filename: "queries.sql" + insert_into_table { name: "teams" } +} +sqlc_version: "v1.29.0" +plugin_options: "{\"cabal_default_extensions\":[\"NoFieldSelectors\"],\"cabal_package_name\":\"pulse-db\",\"haskell_module_prefix\":\"Pulse.Database\",\"overrides\":[{\"db_type\":\"pg_catalog.timestamptz\",\"haskell_type\":{\"module\":\"Data.Time\",\"package\":\"time\",\"type\":\"Maybe Data.Time.UTCTime\"}, \"nullable\": true}, {\"db_type\":\"pg_catalog.timestamptz\",\"haskell_type\":{\"module\":\"Data.Time\",\"package\":\"time\",\"type\":\"Data.Time.UTCTime\"}}]}" diff --git a/test/golden/pulse/Pulse/Database.hs b/test/golden/pulse/Pulse/Database.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database.hs @@ -0,0 +1,20 @@ +module Pulse.Database + ( module Pulse.Database.Internal, + module Pulse.Database.Types, + module Queries + ) +where + +import Pulse.Database.Internal +import Pulse.Database.Types +import Pulse.Database.GetLoginById as Queries +import Pulse.Database.GetLoginByName as Queries +import Pulse.Database.GetLoginOrganizations as Queries +import Pulse.Database.GetOrganizations as Queries +import Pulse.Database.GetTeams as Queries +import Pulse.Database.GetTeamById as Queries +import Pulse.Database.GetTeamByInvitationCode as Queries +import Pulse.Database.GetTeamMembers as Queries +import Pulse.Database.InsertTeamMember as Queries +import Pulse.Database.GetTeamByName as Queries +import Pulse.Database.InsertTeam as Queries diff --git a/test/golden/pulse/Pulse/Database/GetLoginById.hs b/test/golden/pulse/Pulse/Database/GetLoginById.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/GetLoginById.hs @@ -0,0 +1,62 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetLoginById where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getLoginById :: Query "getLoginById" ":one" +query_getLoginById = Query "SELECT id, organization_id, display_name, login_name, password_bcrypt, is_deleted, created_at, updated_at FROM logins WHERE id = ? AND NOT is_deleted" + +data instance Params "getLoginById" = Params_getLoginById + { + logins_id :: Data.Int.Int32 + } + +data instance Result "getLoginById" = Result_getLoginById + { + logins_id :: !(Data.Int.Int32), + logins_organization_id :: !(Data.Int.Int32), + logins_display_name :: !(GHC.Base.Maybe Data.Text.Text), + logins_login_name :: !(Data.Text.Text), + logins_password_bcrypt :: !(Data.Text.Text), + logins_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + logins_created_at :: !((Maybe Data.Time.UTCTime)), + logins_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getLoginById") where + toRow Params_getLoginById{..} = + [ + Database.PostgreSQL.Simple.ToField.toField logins_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getLoginById") where + fromRow = + pure Result_getLoginById + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/GetLoginByName.hs b/test/golden/pulse/Pulse/Database/GetLoginByName.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/GetLoginByName.hs @@ -0,0 +1,62 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetLoginByName where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Text +import qualified Data.Int +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getLoginByName :: Query "getLoginByName" ":one" +query_getLoginByName = Query "SELECT id, organization_id, display_name, login_name, password_bcrypt, is_deleted, created_at, updated_at FROM logins WHERE login_name = ? AND NOT is_deleted" + +data instance Params "getLoginByName" = Params_getLoginByName + { + logins_login_name :: Data.Text.Text + } + +data instance Result "getLoginByName" = Result_getLoginByName + { + logins_id :: !(Data.Int.Int32), + logins_organization_id :: !(Data.Int.Int32), + logins_display_name :: !(GHC.Base.Maybe Data.Text.Text), + logins_login_name :: !(Data.Text.Text), + logins_password_bcrypt :: !(Data.Text.Text), + logins_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + logins_created_at :: !((Maybe Data.Time.UTCTime)), + logins_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getLoginByName") where + toRow Params_getLoginByName{..} = + [ + Database.PostgreSQL.Simple.ToField.toField logins_login_name + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getLoginByName") where + fromRow = + pure Result_getLoginByName + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/GetLoginOrganizations.hs b/test/golden/pulse/Pulse/Database/GetLoginOrganizations.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/GetLoginOrganizations.hs @@ -0,0 +1,70 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetLoginOrganizations where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getLoginOrganizations :: Query "getLoginOrganizations" ":many" +query_getLoginOrganizations = Query "SELECT logins.id, logins.organization_id, logins.display_name, logins.login_name, logins.password_bcrypt, logins.is_deleted, logins.created_at, logins.updated_at, organizations.id, organizations.display_name, organizations.created_at, organizations.updated_at\n FROM logins\n JOIN organization_logins ON logins.id = organization_logins.login_id\n JOIN organizations ON organizations.id = organization_logins.organization_id\n WHERE\n logins.id = ? AND NOT logins.is_deleted" + +data instance Params "getLoginOrganizations" = Params_getLoginOrganizations + { + logins_id :: Data.Int.Int32 + } + +data instance Result "getLoginOrganizations" = Result_getLoginOrganizations + { + logins_id :: !(Data.Int.Int32), + logins_organization_id :: !(Data.Int.Int32), + logins_display_name :: !(GHC.Base.Maybe Data.Text.Text), + logins_login_name :: !(Data.Text.Text), + logins_password_bcrypt :: !(Data.Text.Text), + logins_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + logins_created_at :: !((Maybe Data.Time.UTCTime)), + logins_updated_at :: !((Maybe Data.Time.UTCTime)), + organizations_id :: !(Data.Int.Int32), + organizations_display_name :: !(Data.Text.Text), + organizations_created_at :: !((Maybe Data.Time.UTCTime)), + organizations_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getLoginOrganizations") where + toRow Params_getLoginOrganizations{..} = + [ + Database.PostgreSQL.Simple.ToField.toField logins_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getLoginOrganizations") where + fromRow = + pure Result_getLoginOrganizations + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/GetOrganizations.hs b/test/golden/pulse/Pulse/Database/GetOrganizations.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/GetOrganizations.hs @@ -0,0 +1,49 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetOrganizations where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified Data.Time +import qualified Data.Foldable + +query_getOrganizations :: Query "getOrganizations" ":many" +query_getOrganizations = Query "SELECT id, display_name, created_at, updated_at FROM organizations LIMIT 100" + +data instance Params "getOrganizations" = Params_getOrganizations + { + } + +data instance Result "getOrganizations" = Result_getOrganizations + { + organizations_id :: !(Data.Int.Int32), + organizations_display_name :: !(Data.Text.Text), + organizations_created_at :: !((Maybe Data.Time.UTCTime)), + organizations_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getOrganizations") where + toRow Params_getOrganizations{} = + [ ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getOrganizations") where + fromRow = + pure Result_getOrganizations + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/GetTeamById.hs b/test/golden/pulse/Pulse/Database/GetTeamById.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/GetTeamById.hs @@ -0,0 +1,63 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeamById where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_getTeamById :: Query "getTeamById" ":one" +query_getTeamById = Query "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams WHERE organization_id = ? AND id = ? AND NOT is_deleted" + +data instance Params "getTeamById" = Params_getTeamById + { + teams_organization_id :: Data.Int.Int32, + teams_id :: Data.Int.Int32 + } + +data instance Result "getTeamById" = Result_getTeamById + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeamById") where + toRow Params_getTeamById{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id, + + Database.PostgreSQL.Simple.ToField.toField teams_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeamById") where + fromRow = + pure Result_getTeamById + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/GetTeamByInvitationCode.hs b/test/golden/pulse/Pulse/Database/GetTeamByInvitationCode.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/GetTeamByInvitationCode.hs @@ -0,0 +1,68 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeamByInvitationCode where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Text +import qualified Data.Int +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_getTeamByInvitationCode :: Query "getTeamByInvitationCode" ":one" +query_getTeamByInvitationCode = Query "SELECT teams.id, organization_id, teams.display_name, invitation_code, is_deleted, teams.created_at, teams.updated_at, organizations.id, organizations.display_name, organizations.created_at, organizations.updated_at FROM teams JOIN organizations ON teams.organization_id = organizations.id WHERE invitation_code = ? AND NOT is_deleted" + +data instance Params "getTeamByInvitationCode" = Params_getTeamByInvitationCode + { + teams_invitation_code :: Data.Text.Text + } + +data instance Result "getTeamByInvitationCode" = Result_getTeamByInvitationCode + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)), + organizations_id :: !(Data.Int.Int32), + organizations_display_name :: !(Data.Text.Text), + organizations_created_at :: !((Maybe Data.Time.UTCTime)), + organizations_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeamByInvitationCode") where + toRow Params_getTeamByInvitationCode{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_invitation_code + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeamByInvitationCode") where + fromRow = + pure Result_getTeamByInvitationCode + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/GetTeamByName.hs b/test/golden/pulse/Pulse/Database/GetTeamByName.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/GetTeamByName.hs @@ -0,0 +1,63 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeamByName where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_getTeamByName :: Query "getTeamByName" ":one" +query_getTeamByName = Query "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams WHERE organization_id = ? AND display_name = ?" + +data instance Params "getTeamByName" = Params_getTeamByName + { + teams_organization_id :: Data.Int.Int32, + teams_display_name :: Data.Text.Text + } + +data instance Result "getTeamByName" = Result_getTeamByName + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeamByName") where + toRow Params_getTeamByName{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id, + + Database.PostgreSQL.Simple.ToField.toField teams_display_name + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeamByName") where + fromRow = + pure Result_getTeamByName + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/GetTeamMembers.hs b/test/golden/pulse/Pulse/Database/GetTeamMembers.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/GetTeamMembers.hs @@ -0,0 +1,70 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeamMembers where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Base +import qualified GHC.Types +import qualified Data.Time +import qualified Data.Foldable + +query_getTeamMembers :: Query "getTeamMembers" ":many" +query_getTeamMembers = Query "SELECT id, organization_id, display_name, login_name, password_bcrypt, is_deleted, logins.created_at, logins.updated_at, team_id, login_id, team_members.created_at, team_members.updated_at FROM logins JOIN team_members ON logins.id = team_members.login_id WHERE team_id = ?" + +data instance Params "getTeamMembers" = Params_getTeamMembers + { + team_members_team_id :: Data.Int.Int32 + } + +data instance Result "getTeamMembers" = Result_getTeamMembers + { + logins_id :: !(Data.Int.Int32), + logins_organization_id :: !(Data.Int.Int32), + logins_display_name :: !(GHC.Base.Maybe Data.Text.Text), + logins_login_name :: !(Data.Text.Text), + logins_password_bcrypt :: !(Data.Text.Text), + logins_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + logins_created_at :: !((Maybe Data.Time.UTCTime)), + logins_updated_at :: !((Maybe Data.Time.UTCTime)), + team_members_team_id :: !(Data.Int.Int32), + team_members_login_id :: !(Data.Int.Int32), + team_members_created_at :: !((Maybe Data.Time.UTCTime)), + team_members_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeamMembers") where + toRow Params_getTeamMembers{..} = + [ + Database.PostgreSQL.Simple.ToField.toField team_members_team_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeamMembers") where + fromRow = + pure Result_getTeamMembers + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/GetTeams.hs b/test/golden/pulse/Pulse/Database/GetTeams.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/GetTeams.hs @@ -0,0 +1,60 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.GetTeams where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_getTeams :: Query "getTeams" ":many" +query_getTeams = Query "SELECT id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at FROM teams WHERE organization_id = ? AND NOT is_deleted ORDER BY display_name ASC" + +data instance Params "getTeams" = Params_getTeams + { + teams_organization_id :: Data.Int.Int32 + } + +data instance Result "getTeams" = Result_getTeams + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "getTeams") where + toRow Params_getTeams{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "getTeams") where + fromRow = + pure Result_getTeams + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/InsertTeam.hs b/test/golden/pulse/Pulse/Database/InsertTeam.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/InsertTeam.hs @@ -0,0 +1,66 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertTeam where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Text +import qualified GHC.Types +import qualified GHC.Base +import qualified Data.Time +import qualified Data.Foldable + +query_insertTeam :: Query "insertTeam" ":one" +query_insertTeam = Query "INSERT INTO teams (organization_id, display_name, invitation_code, is_deleted) VALUES (?, ?, ?, false) RETURNING id, organization_id, display_name, invitation_code, is_deleted, created_at, updated_at" + +data instance Params "insertTeam" = Params_insertTeam + { + teams_organization_id :: Data.Int.Int32, + teams_display_name :: Data.Text.Text, + teams_invitation_code :: Data.Text.Text + } + +data instance Result "insertTeam" = Result_insertTeam + { + teams_id :: !(Data.Int.Int32), + teams_organization_id :: !(Data.Int.Int32), + teams_display_name :: !(Data.Text.Text), + teams_invitation_code :: !(Data.Text.Text), + teams_is_deleted :: !(GHC.Base.Maybe GHC.Types.Bool), + teams_created_at :: !((Maybe Data.Time.UTCTime)), + teams_updated_at :: !((Maybe Data.Time.UTCTime)) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertTeam") where + toRow Params_insertTeam{..} = + [ + Database.PostgreSQL.Simple.ToField.toField teams_organization_id, + + Database.PostgreSQL.Simple.ToField.toField teams_display_name, + + Database.PostgreSQL.Simple.ToField.toField teams_invitation_code + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertTeam") where + fromRow = + pure Result_insertTeam + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/pulse/Pulse/Database/InsertTeamMember.hs b/test/golden/pulse/Pulse/Database/InsertTeamMember.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/InsertTeamMember.hs @@ -0,0 +1,45 @@ +{- This file was auto-generated from queries.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.InsertTeamMember where + +import Pulse.Database.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Int +import qualified Data.Foldable + +query_insertTeamMember :: Query "insertTeamMember" ":exec" +query_insertTeamMember = Query "INSERT INTO team_members (team_id, login_id) VALUES (?, ?) ON CONFLICT (team_id, login_id) DO NOTHING" + +data instance Params "insertTeamMember" = Params_insertTeamMember + { + team_members_team_id :: Data.Int.Int32, + team_members_login_id :: Data.Int.Int32 + } + +data instance Result "insertTeamMember" = Result_insertTeamMember + { + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "insertTeamMember") where + toRow Params_insertTeamMember{..} = + [ + Database.PostgreSQL.Simple.ToField.toField team_members_team_id, + + Database.PostgreSQL.Simple.ToField.toField team_members_login_id + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "insertTeamMember") where + fromRow = + pure Result_insertTeamMember + + diff --git a/test/golden/pulse/Pulse/Database/Internal.hs b/test/golden/pulse/Pulse/Database/Internal.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/Internal.hs @@ -0,0 +1,132 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.Internal ( + Query(..), + Params, + Result, + Pulse.Database.Internal.Enum, + + -- * :execResult + ExecResult(..), + execResult, + + -- * :exec + exec, + + -- * :execrows + execRows, + + -- * :one + queryOne, + + -- * :many + queryMany, + fold, + + -- * :copyfrom + execMany, + + -- * Reexports + Database.PostgreSQL.Simple.Connection, + Database.PostgreSQL.Simple.ToRow, + Database.PostgreSQL.Simple.FromRow, + ) where + +import Data.Foldable (Foldable) +import qualified Data.Foldable +import Data.Vector (Vector) +import Database.PostgreSQL.Simple (Connection, FromRow, ToRow) +import GHC.TypeLits (Symbol) +import qualified Data.ByteString.Char8 +import qualified Data.Int +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.Types +import qualified Database.PostgreSQL.Simple.Vector + +newtype Query (name :: Symbol) (command :: Symbol) + = Query Database.PostgreSQL.Simple.Query + +data family Params (name :: Symbol) + +data family Result (name :: Symbol) + +data family Enum (name :: Symbol) + +data ExecResult = ExecResult + { rowsAffected :: !Data.Int.Int64 + } + +exec :: + (ToRow (Params name)) => + Connection -> + Query name ":exec" -> + Params name -> + IO () +exec connection (Query sql) params = do + _rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure () + +execRows :: + (ToRow (Params name)) => + Connection -> + Query name ":execrows" -> + Params name -> + IO Data.Int.Int64 +execRows connection (Query sql) params = do + Database.PostgreSQL.Simple.execute connection sql params + +execResult :: + (ToRow (Params name)) => + Connection -> + Query name ":execresult" -> + Params name -> + IO ExecResult +execResult connection (Query sql) params = do + rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure ExecResult { + rowsAffected + } + +queryOne :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":one" -> + Params name -> + IO (Maybe (Result name)) +queryOne connection (Query sql) params = do + result <- Database.PostgreSQL.Simple.query connection sql params + case result of + [] -> pure Nothing + x : _ -> pure (Just x) + +queryMany :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + IO (Vector (Result name)) +queryMany connection (Query sql) params = + Database.PostgreSQL.Simple.Vector.query connection sql params + +execMany :: + (ToRow (Params name), FromRow (Result name), Foldable f) => + Connection -> + Query name ":copyfrom" -> + f (Params name) -> + IO Data.Int.Int64 +execMany connection (Query sql) params = + Database.PostgreSQL.Simple.executeMany connection sql (Data.Foldable.toList params) + +fold :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + a -> + (a -> Result name -> IO a) -> + IO a +fold connection (Query sql) params = do + Database.PostgreSQL.Simple.fold connection sql params +{-# INLINABLE fold #-} diff --git a/test/golden/pulse/Pulse/Database/Types.hs b/test/golden/pulse/Pulse/Database/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/pulse/Pulse/Database/Types.hs @@ -0,0 +1,45 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Pulse.Database.Types where + +import qualified Control.Monad +import qualified Data.Text +import qualified Database.PostgreSQL.Simple.FromField +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow +import Pulse.Database.Internal +import Prelude hiding (Enum) +import qualified Prelude + +data instance Enum "organization_role" + = Enum_organization_role_owner + | Enum_organization_role_admin + | Enum_organization_role_member + deriving stock (Eq, Ord, Show, Bounded, Prelude.Enum) + +instance Database.PostgreSQL.Simple.ToField.ToField (Enum "organization_role") where + toField Enum_organization_role_owner = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "owner" + toField Enum_organization_role_admin = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "admin" + toField Enum_organization_role_member = Database.PostgreSQL.Simple.ToField.toField @Data.Text.Text "member" + +instance Database.PostgreSQL.Simple.FromField.FromField (Enum "organization_role") where + fromField field value = do + typename <- Database.PostgreSQL.Simple.FromField.typename field + Control.Monad.when (typename /= "organization_role") $ + Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.Incompatible field "" + case value of + Just "owner" -> pure Enum_organization_role_owner + Just "admin" -> pure Enum_organization_role_admin + Just "member" -> pure Enum_organization_role_member + Just value -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.ConversionFailed field (show value) + Nothing -> Database.PostgreSQL.Simple.FromField.returnError Database.PostgreSQL.Simple.FromField.UnexpectedNull field "" + diff --git a/test/golden/pulse/pulse-db.cabal b/test/golden/pulse/pulse-db.cabal new file mode 100644 --- /dev/null +++ b/test/golden/pulse/pulse-db.cabal @@ -0,0 +1,29 @@ +cabal-version: 3.0 +name: pulse-db +version: 0.1.0.0 +library + build-depends: + base, + bytestring, + ghc-prim, + postgresql-simple, + text, + time, + vector, + exposed-modules: + Pulse.Database + Pulse.Database.GetLoginById + Pulse.Database.GetLoginByName + Pulse.Database.GetLoginOrganizations + Pulse.Database.GetOrganizations + Pulse.Database.GetTeamById + Pulse.Database.GetTeamByInvitationCode + Pulse.Database.GetTeamByName + Pulse.Database.GetTeamMembers + Pulse.Database.GetTeams + Pulse.Database.InsertTeam + Pulse.Database.InsertTeamMember + Pulse.Database.Internal + Pulse.Database.Types + default-extensions: + NoFieldSelectors diff --git a/test/golden/simple-query-mysql.input b/test/golden/simple-query-mysql.input --- a/test/golden/simple-query-mysql.input +++ b/test/golden/simple-query-mysql.input @@ -22,6 +22,7 @@ } } params { + number: 1 column { name: "age" not_null: true diff --git a/test/golden/simple-query-mysql/Queries.hs b/test/golden/simple-query-mysql/Queries.hs --- a/test/golden/simple-query-mysql/Queries.hs +++ b/test/golden/simple-query-mysql/Queries.hs @@ -1,8 +1,10 @@ module Queries ( module Queries.Internal, + module Queries.Types, module Queries ) where -import qualified Queries.Internal -import qualified Queries.ListUsers as Queries +import Queries.Internal +import Queries.Types +import Queries.ListUsers as Queries diff --git a/test/golden/simple-query-mysql/Queries/Internal.hs b/test/golden/simple-query-mysql/Queries/Internal.hs --- a/test/golden/simple-query-mysql/Queries/Internal.hs +++ b/test/golden/simple-query-mysql/Queries/Internal.hs @@ -5,6 +5,7 @@ Query(..), Params, Result, + Queries.Internal.Enum, -- * :execResult ExecResult(..), @@ -45,6 +46,8 @@ data family Params (name :: Symbol) data family Result (name :: Symbol) + +data family Enum (name :: Symbol) data ExecResult = ExecResult { lastInsertId :: !Data.Int.Int64, diff --git a/test/golden/simple-query-mysql/Queries/ListUsers.hs b/test/golden/simple-query-mysql/Queries/ListUsers.hs --- a/test/golden/simple-query-mysql/Queries/ListUsers.hs +++ b/test/golden/simple-query-mysql/Queries/ListUsers.hs @@ -8,7 +8,7 @@ {-# LANGUAGE TypeFamilies #-} module Queries.ListUsers where -import Queries.Internal (Query(..), Params, Result) +import Queries.Internal (Query(..), Enum, Params, Result) import qualified Database.MySQL.Simple.Param import qualified Database.MySQL.Simple.QueryParams import qualified Database.MySQL.Simple.QueryResults @@ -16,9 +16,10 @@ import qualified Data.Int import qualified Data.Text +import qualified Data.Foldable query_ListUsers :: Query "ListUsers" "SELECT" -query_ListUsers = Query "SELECT * FROM users WHERE $1 > 42;" +query_ListUsers = Query "SELECT * FROM users WHERE ? > 42;" data instance Params "ListUsers" = Params_ListUsers { @@ -27,8 +28,8 @@ data instance Result "ListUsers" = Result_ListUsers { - id :: !Data.Int.Int32, - name :: !Data.Text.Text + id :: !(Data.Int.Int32), + name :: !(Data.Text.Text) } diff --git a/test/golden/simple-query-mysql/Queries/Types.hs b/test/golden/simple-query-mysql/Queries/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/simple-query-mysql/Queries/Types.hs @@ -0,0 +1,20 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Types where + +import qualified Database.MySQL.Simple.Param +import qualified Database.MySQL.Simple.QueryParams +import qualified Database.MySQL.Simple.QueryResults +import qualified Database.MySQL.Simple.Result +import Queries.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/simple-query-mysql/simple-query-mysql.cabal b/test/golden/simple-query-mysql/simple-query-mysql.cabal --- a/test/golden/simple-query-mysql/simple-query-mysql.cabal +++ b/test/golden/simple-query-mysql/simple-query-mysql.cabal @@ -4,9 +4,11 @@ library build-depends: base, + bytestring, mysql-simple, text, exposed-modules: Queries Queries.Internal Queries.ListUsers + Queries.Types diff --git a/test/golden/simple-query-postgresql.input b/test/golden/simple-query-postgresql.input --- a/test/golden/simple-query-postgresql.input +++ b/test/golden/simple-query-postgresql.input @@ -22,6 +22,7 @@ } } params { + number: 1 column { name: "age" not_null: true diff --git a/test/golden/simple-query-postgresql/Queries.hs b/test/golden/simple-query-postgresql/Queries.hs --- a/test/golden/simple-query-postgresql/Queries.hs +++ b/test/golden/simple-query-postgresql/Queries.hs @@ -1,8 +1,10 @@ module Queries ( module Queries.Internal, + module Queries.Types, module Queries ) where -import qualified Queries.Internal -import qualified Queries.ListUsers as Queries +import Queries.Internal +import Queries.Types +import Queries.ListUsers as Queries diff --git a/test/golden/simple-query-postgresql/Queries/Internal.hs b/test/golden/simple-query-postgresql/Queries/Internal.hs --- a/test/golden/simple-query-postgresql/Queries/Internal.hs +++ b/test/golden/simple-query-postgresql/Queries/Internal.hs @@ -6,6 +6,7 @@ Query(..), Params, Result, + Queries.Internal.Enum, -- * :execResult ExecResult(..), @@ -24,17 +25,24 @@ queryMany, fold, + -- * :copyfrom + execMany, + -- * Reexports Database.PostgreSQL.Simple.Connection, Database.PostgreSQL.Simple.ToRow, Database.PostgreSQL.Simple.FromRow, ) where +import Data.Foldable (Foldable) +import qualified Data.Foldable import Data.Vector (Vector) import Database.PostgreSQL.Simple (Connection, FromRow, ToRow) import GHC.TypeLits (Symbol) +import qualified Data.ByteString.Char8 import qualified Data.Int import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.Types import qualified Database.PostgreSQL.Simple.Vector newtype Query (name :: Symbol) (command :: Symbol) @@ -44,6 +52,8 @@ data family Result (name :: Symbol) +data family Enum (name :: Symbol) + data ExecResult = ExecResult { rowsAffected :: !Data.Int.Int64 } @@ -64,8 +74,8 @@ Query name ":execrows" -> Params name -> IO Data.Int.Int64 -execRows connection (Query sql) = do - Database.PostgreSQL.Simple.execute connection sql +execRows connection (Query sql) params = do + Database.PostgreSQL.Simple.execute connection sql params execResult :: (ToRow (Params name)) => @@ -97,9 +107,18 @@ Query name ":many" -> Params name -> IO (Vector (Result name)) -queryMany connection (Query sql) = - Database.PostgreSQL.Simple.Vector.query connection sql +queryMany connection (Query sql) params = + Database.PostgreSQL.Simple.Vector.query connection sql params +execMany :: + (ToRow (Params name), FromRow (Result name), Foldable f) => + Connection -> + Query name ":copyfrom" -> + f (Params name) -> + IO Data.Int.Int64 +execMany connection (Query sql) params = + Database.PostgreSQL.Simple.executeMany connection sql (Data.Foldable.toList params) + fold :: (ToRow (Params name), FromRow (Result name)) => Connection -> @@ -108,6 +127,6 @@ a -> (a -> Result name -> IO a) -> IO a -fold connection (Query sql) = - Database.PostgreSQL.Simple.fold connection sql +fold connection (Query sql) params = do + Database.PostgreSQL.Simple.fold connection sql params {-# INLINABLE fold #-} diff --git a/test/golden/simple-query-postgresql/Queries/ListUsers.hs b/test/golden/simple-query-postgresql/Queries/ListUsers.hs --- a/test/golden/simple-query-postgresql/Queries/ListUsers.hs +++ b/test/golden/simple-query-postgresql/Queries/ListUsers.hs @@ -8,16 +8,18 @@ {-# LANGUAGE TypeFamilies #-} module Queries.ListUsers where -import Queries.Internal (Query(..), Params, Result) +import Queries.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple import qualified Database.PostgreSQL.Simple.FromRow import qualified Database.PostgreSQL.Simple.ToField import qualified Database.PostgreSQL.Simple.ToRow import qualified Data.Int import qualified Data.Text +import qualified Data.Foldable query_ListUsers :: Query "ListUsers" "SELECT" -query_ListUsers = Query "SELECT * FROM users WHERE $1 > 42;" +query_ListUsers = Query "SELECT * FROM users WHERE ? > 42;" data instance Params "ListUsers" = Params_ListUsers { @@ -26,8 +28,8 @@ data instance Result "ListUsers" = Result_ListUsers { - id :: !Data.Int.Int32, - name :: !Data.Text.Text + id :: !(Data.Int.Int32), + name :: !(Data.Text.Text) } instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "ListUsers") where @@ -38,8 +40,8 @@ instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "ListUsers") where fromRow = - Result_ListUsers - <$> Database.PostgreSQL.Simple.FromRow.field + pure Result_ListUsers + <*> Database.PostgreSQL.Simple.FromRow.field <*> Database.PostgreSQL.Simple.FromRow.field diff --git a/test/golden/simple-query-postgresql/Queries/Types.hs b/test/golden/simple-query-postgresql/Queries/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/simple-query-postgresql/Queries/Types.hs @@ -0,0 +1,22 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Types where + +import qualified Control.Monad +import qualified Data.Text +import qualified Database.PostgreSQL.Simple.FromField +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow +import Queries.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/simple-query-postgresql/simple-query-postgresql.cabal b/test/golden/simple-query-postgresql/simple-query-postgresql.cabal --- a/test/golden/simple-query-postgresql/simple-query-postgresql.cabal +++ b/test/golden/simple-query-postgresql/simple-query-postgresql.cabal @@ -4,6 +4,7 @@ library build-depends: base, + bytestring, postgresql-simple, text, vector, @@ -11,3 +12,4 @@ Queries Queries.Internal Queries.ListUsers + Queries.Types diff --git a/test/golden/simple-query-sqlite.input b/test/golden/simple-query-sqlite.input --- a/test/golden/simple-query-sqlite.input +++ b/test/golden/simple-query-sqlite.input @@ -22,6 +22,7 @@ } } params { + number: 1 column { name: "age" not_null: true @@ -32,4 +33,4 @@ } } -global_options: "{ \"cabal_package_name\": \"simple-query-sqlite\" }" +global_options: "{ \"cabal_package_name\": \"simple-query-sqlite\", \"cabal_default_extensions\": [\"OverloadedStrings\", \"StrictData\"] }" diff --git a/test/golden/simple-query-sqlite/Queries.hs b/test/golden/simple-query-sqlite/Queries.hs --- a/test/golden/simple-query-sqlite/Queries.hs +++ b/test/golden/simple-query-sqlite/Queries.hs @@ -1,8 +1,10 @@ module Queries ( module Queries.Internal, + module Queries.Types, module Queries ) where -import qualified Queries.Internal -import qualified Queries.ListUsers as Queries +import Queries.Internal +import Queries.Types +import Queries.ListUsers as Queries diff --git a/test/golden/simple-query-sqlite/Queries/Internal.hs b/test/golden/simple-query-sqlite/Queries/Internal.hs --- a/test/golden/simple-query-sqlite/Queries/Internal.hs +++ b/test/golden/simple-query-sqlite/Queries/Internal.hs @@ -7,6 +7,7 @@ Query(..), Params, Result, + Queries.Internal.Enum, -- * :execResult ExecResult(..), @@ -47,6 +48,8 @@ data family Params (name :: Symbol) data family Result (name :: Symbol) + +data family Enum (name :: Symbol) data ExecResult = ExecResult { lastInsertId :: !Data.Int.Int64, diff --git a/test/golden/simple-query-sqlite/Queries/ListUsers.hs b/test/golden/simple-query-sqlite/Queries/ListUsers.hs --- a/test/golden/simple-query-sqlite/Queries/ListUsers.hs +++ b/test/golden/simple-query-sqlite/Queries/ListUsers.hs @@ -8,16 +8,17 @@ {-# LANGUAGE TypeFamilies #-} module Queries.ListUsers where -import Queries.Internal (Query(..), Params, Result) +import Queries.Internal (Query(..), Enum, Params, Result) import qualified Database.SQLite.Simple.FromRow import qualified Database.SQLite.Simple.ToField import qualified Database.SQLite.Simple.ToRow import qualified Data.Int import qualified Data.Text +import qualified Data.Foldable query_ListUsers :: Query "ListUsers" "SELECT" -query_ListUsers = Query "SELECT * FROM users WHERE $1 > 42;" +query_ListUsers = Query "SELECT * FROM users WHERE ? > 42;" data instance Params "ListUsers" = Params_ListUsers { @@ -26,8 +27,8 @@ data instance Result "ListUsers" = Result_ListUsers { - id :: !Data.Int.Int64, - name :: !Data.Text.Text + id :: !(Data.Int.Int64), + name :: !(Data.Text.Text) } @@ -39,7 +40,7 @@ instance Database.SQLite.Simple.FromRow.FromRow (Result "ListUsers") where fromRow = - Result_ListUsers - <$> Database.SQLite.Simple.FromRow.field + pure Result_ListUsers + <*> Database.SQLite.Simple.FromRow.field <*> Database.SQLite.Simple.FromRow.field diff --git a/test/golden/simple-query-sqlite/Queries/Types.hs b/test/golden/simple-query-sqlite/Queries/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/simple-query-sqlite/Queries/Types.hs @@ -0,0 +1,19 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Types where + +import qualified Database.SQLite.Simple.FromRow +import qualified Database.SQLite.Simple.ToField +import qualified Database.SQLite.Simple.ToRow +import Queries.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/simple-query-sqlite/simple-query-sqlite.cabal b/test/golden/simple-query-sqlite/simple-query-sqlite.cabal --- a/test/golden/simple-query-sqlite/simple-query-sqlite.cabal +++ b/test/golden/simple-query-sqlite/simple-query-sqlite.cabal @@ -4,6 +4,7 @@ library build-depends: base, + bytestring, sqlite-simple, text, vector, @@ -11,3 +12,7 @@ Queries Queries.Internal Queries.ListUsers + Queries.Types + default-extensions: + OverloadedStrings + StrictData diff --git a/test/golden/slices.input b/test/golden/slices.input new file mode 100644 --- /dev/null +++ b/test/golden/slices.input @@ -0,0 +1,47 @@ +settings { + engine: "postgresql" +} + +queries { + text: "SELECT * FROM users WHERE name IN ($1) AND $2 > 42;" + name: "ListUsers" + cmd: "SELECT" + filename: "query/users.sql" + columns { + name: "id" + not_null: true + type { + name: "int" + } + } + columns { + name: "name" + not_null: true + type { + name: "text" + } + } + params { + number: 1 + column { + name: "names" + not_null: true + type { + name: "text" + } + is_sqlc_slice: true + } + } + params { + number: 2 + column { + name: "age" + not_null: true + type { + name: "int" + } + } + } +} + +global_options: "{ \"cabal_package_name\": \"simple-query-postgresql\" }" diff --git a/test/golden/slices/Queries.hs b/test/golden/slices/Queries.hs new file mode 100644 --- /dev/null +++ b/test/golden/slices/Queries.hs @@ -0,0 +1,10 @@ +module Queries + ( module Queries.Internal, + module Queries.Types, + module Queries + ) +where + +import Queries.Internal +import Queries.Types +import Queries.ListUsers as Queries diff --git a/test/golden/slices/Queries/Internal.hs b/test/golden/slices/Queries/Internal.hs new file mode 100644 --- /dev/null +++ b/test/golden/slices/Queries/Internal.hs @@ -0,0 +1,132 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Internal ( + Query(..), + Params, + Result, + Queries.Internal.Enum, + + -- * :execResult + ExecResult(..), + execResult, + + -- * :exec + exec, + + -- * :execrows + execRows, + + -- * :one + queryOne, + + -- * :many + queryMany, + fold, + + -- * :copyfrom + execMany, + + -- * Reexports + Database.PostgreSQL.Simple.Connection, + Database.PostgreSQL.Simple.ToRow, + Database.PostgreSQL.Simple.FromRow, + ) where + +import Data.Foldable (Foldable) +import qualified Data.Foldable +import Data.Vector (Vector) +import Database.PostgreSQL.Simple (Connection, FromRow, ToRow) +import GHC.TypeLits (Symbol) +import qualified Data.ByteString.Char8 +import qualified Data.Int +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.Types +import qualified Database.PostgreSQL.Simple.Vector + +newtype Query (name :: Symbol) (command :: Symbol) + = Query Database.PostgreSQL.Simple.Query + +data family Params (name :: Symbol) + +data family Result (name :: Symbol) + +data family Enum (name :: Symbol) + +data ExecResult = ExecResult + { rowsAffected :: !Data.Int.Int64 + } + +exec :: + (ToRow (Params name)) => + Connection -> + Query name ":exec" -> + Params name -> + IO () +exec connection (Query sql) params = do + _rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure () + +execRows :: + (ToRow (Params name)) => + Connection -> + Query name ":execrows" -> + Params name -> + IO Data.Int.Int64 +execRows connection (Query sql) params = do + Database.PostgreSQL.Simple.execute connection sql params + +execResult :: + (ToRow (Params name)) => + Connection -> + Query name ":execresult" -> + Params name -> + IO ExecResult +execResult connection (Query sql) params = do + rowsAffected <- Database.PostgreSQL.Simple.execute connection sql params + pure ExecResult { + rowsAffected + } + +queryOne :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":one" -> + Params name -> + IO (Maybe (Result name)) +queryOne connection (Query sql) params = do + result <- Database.PostgreSQL.Simple.query connection sql params + case result of + [] -> pure Nothing + x : _ -> pure (Just x) + +queryMany :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + IO (Vector (Result name)) +queryMany connection (Query sql) params = + Database.PostgreSQL.Simple.Vector.query connection sql params + +execMany :: + (ToRow (Params name), FromRow (Result name), Foldable f) => + Connection -> + Query name ":copyfrom" -> + f (Params name) -> + IO Data.Int.Int64 +execMany connection (Query sql) params = + Database.PostgreSQL.Simple.executeMany connection sql (Data.Foldable.toList params) + +fold :: + (ToRow (Params name), FromRow (Result name)) => + Connection -> + Query name ":many" -> + Params name -> + a -> + (a -> Result name -> IO a) -> + IO a +fold connection (Query sql) params = do + Database.PostgreSQL.Simple.fold connection sql params +{-# INLINABLE fold #-} diff --git a/test/golden/slices/Queries/ListUsers.hs b/test/golden/slices/Queries/ListUsers.hs new file mode 100644 --- /dev/null +++ b/test/golden/slices/Queries/ListUsers.hs @@ -0,0 +1,50 @@ +{- This file was auto-generated from query/users.sql by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.ListUsers where + +import Queries.Internal (Query(..), Enum, Params, Result) +import qualified Database.PostgreSQL.Simple +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow + +import qualified Data.Text +import qualified Data.Int +import qualified Data.Foldable + +query_ListUsers :: Query "ListUsers" "SELECT" +query_ListUsers = Query "SELECT * FROM users WHERE name IN ? AND ? > 42;" + +data instance Params "ListUsers" = Params_ListUsers + { + names :: [Data.Text.Text], + age :: Data.Int.Int32 + } + +data instance Result "ListUsers" = Result_ListUsers + { + id :: !(Data.Int.Int32), + name :: !(Data.Text.Text) + } + +instance Database.PostgreSQL.Simple.ToRow.ToRow (Params "ListUsers") where + toRow Params_ListUsers{..} = + [ + Database.PostgreSQL.Simple.ToField.toField (Database.PostgreSQL.Simple.In (Data.Foldable.toList names)), + + Database.PostgreSQL.Simple.ToField.toField age + ] + +instance Database.PostgreSQL.Simple.FromRow.FromRow (Result "ListUsers") where + fromRow = + pure Result_ListUsers + <*> Database.PostgreSQL.Simple.FromRow.field + <*> Database.PostgreSQL.Simple.FromRow.field + + diff --git a/test/golden/slices/Queries/Types.hs b/test/golden/slices/Queries/Types.hs new file mode 100644 --- /dev/null +++ b/test/golden/slices/Queries/Types.hs @@ -0,0 +1,22 @@ +{- This file was auto-generated by sqlc-hs. -} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DerivingStrategies #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeFamilies #-} +module Queries.Types where + +import qualified Control.Monad +import qualified Data.Text +import qualified Database.PostgreSQL.Simple.FromField +import qualified Database.PostgreSQL.Simple.FromRow +import qualified Database.PostgreSQL.Simple.ToField +import qualified Database.PostgreSQL.Simple.ToRow +import Queries.Internal +import Prelude hiding (Enum) +import qualified Prelude + diff --git a/test/golden/slices/simple-query-postgresql.cabal b/test/golden/slices/simple-query-postgresql.cabal new file mode 100644 --- /dev/null +++ b/test/golden/slices/simple-query-postgresql.cabal @@ -0,0 +1,15 @@ +cabal-version: 3.0 +name: simple-query-postgresql +version: 0.1.0.0 +library + build-depends: + base, + bytestring, + postgresql-simple, + text, + vector, + exposed-modules: + Queries + Queries.Internal + Queries.ListUsers + Queries.Types