From f21078a7b15edee3331ffac65ea25bfc5a8d059d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=98yvind=20Raddum=20Berg?= Date: Fri, 26 Jul 2024 00:35:37 +0200 Subject: [PATCH] Add support for generating code without schema reference with supplying `SchemaMode` (Experimental, fixes #123) (#126) --- sql/custom/domains.sql | 2 +- sql/custom/enums.sql | 2 +- sql/custom/table_comments.sql | 2 +- .../src/scala/scripts/CompileBenchmark.scala | 2 +- .../scripts/GeneratedAdventureWorks.scala | 2 +- .../constraints/ConstraintsSqlRow.scala | 5 +- .../custom/domains/DomainsSqlRepoImpl.scala | 2 +- .../custom/domains/DomainsSqlRow.scala | 10 +-- .../custom/enums/EnumsSqlRepoImpl.scala | 2 +- .../generated/custom/enums/EnumsSqlRow.scala | 10 +-- .../TableCommentsSqlRepoImpl.scala | 2 +- .../table_comments/TableCommentsSqlRow.scala | 10 +-- .../information_schema/CardinalNumber.scala | 39 +++++++++ .../information_schema/CharacterData.scala | 39 +++++++++ .../information_schema/SqlIdentifier.scala | 39 +++++++++ .../information_schema/TimeStamp.scala | 40 +++++++++ .../information_schema/YesOrNo.scala | 39 +++++++++ .../pg_namespace/PgNamespaceRow.scala | 8 +- .../typo/generated/public/AccountNumber.scala | 39 +++++++++ .../typo/generated/public/Flag.scala | 39 +++++++++ .../typo/generated/public/Mydomain.scala | 39 +++++++++ .../typo/generated/public/Name.scala | 39 +++++++++ .../typo/generated/public/NameStyle.scala | 39 +++++++++ .../typo/generated/public/OrderNumber.scala | 39 +++++++++ .../typo/generated/public/Phone.scala | 39 +++++++++ .../typo/generated/public/ShortText.scala | 39 +++++++++ typo/src/scala/typo/MetaDb.scala | 83 ++++++++++++++----- typo/src/scala/typo/Options.scala | 3 +- typo/src/scala/typo/generateFromDb.scala | 2 +- .../scala/typo/internal/metadb/Enums.scala | 2 +- 30 files changed, 605 insertions(+), 52 deletions(-) create mode 100644 typo/generated-and-checked-in/typo/generated/information_schema/CardinalNumber.scala create mode 100644 typo/generated-and-checked-in/typo/generated/information_schema/CharacterData.scala create mode 100644 typo/generated-and-checked-in/typo/generated/information_schema/SqlIdentifier.scala create mode 100644 typo/generated-and-checked-in/typo/generated/information_schema/TimeStamp.scala create mode 100644 typo/generated-and-checked-in/typo/generated/information_schema/YesOrNo.scala create mode 100644 typo/generated-and-checked-in/typo/generated/public/AccountNumber.scala create mode 100644 typo/generated-and-checked-in/typo/generated/public/Flag.scala create mode 100644 typo/generated-and-checked-in/typo/generated/public/Mydomain.scala create mode 100644 typo/generated-and-checked-in/typo/generated/public/Name.scala create mode 100644 typo/generated-and-checked-in/typo/generated/public/NameStyle.scala create mode 100644 typo/generated-and-checked-in/typo/generated/public/OrderNumber.scala create mode 100644 typo/generated-and-checked-in/typo/generated/public/Phone.scala create mode 100644 typo/generated-and-checked-in/typo/generated/public/ShortText.scala diff --git a/sql/custom/domains.sql b/sql/custom/domains.sql index f8ef083265..d7e5653008 100644 --- a/sql/custom/domains.sql +++ b/sql/custom/domains.sql @@ -1,4 +1,4 @@ -SELECT nsp.nspname as "schema", +SELECT nsp.nspname as "schema?", typ.typname as "name", tt.typname as "type", pc.collname as "collation", diff --git a/sql/custom/enums.sql b/sql/custom/enums.sql index c4dd2986e5..965e1a719e 100644 --- a/sql/custom/enums.sql +++ b/sql/custom/enums.sql @@ -1,4 +1,4 @@ -select n.nspname as enum_schema, +select n.nspname as "enum_schema?", t.typname as enum_name, e.enumsortorder as enum_sort_order, e.enumlabel as enum_value diff --git a/sql/custom/table_comments.sql b/sql/custom/table_comments.sql index 53520433be..33707de4df 100644 --- a/sql/custom/table_comments.sql +++ b/sql/custom/table_comments.sql @@ -1,4 +1,4 @@ -SELECT n.nspname as schema, +SELECT n.nspname as "schema?", c.relname as name, pg_catalog.obj_description(c.oid, 'pg_class') as description FROM pg_catalog.pg_class c diff --git a/typo-scripts/src/scala/scripts/CompileBenchmark.scala b/typo-scripts/src/scala/scripts/CompileBenchmark.scala index c22c302297..70ca23e713 100644 --- a/typo-scripts/src/scala/scripts/CompileBenchmark.scala +++ b/typo-scripts/src/scala/scripts/CompileBenchmark.scala @@ -28,7 +28,7 @@ object CompileBenchmark extends BleepScript("CompileBenchmark") { override def run(started: Started, commands: Commands, args: List[String]): Unit = { val ds = TypoDataSource.hikari(server = "localhost", port = 6432, databaseName = "Adventureworks", username = "postgres", password = "password") - val metadb = Await.result(MetaDb.fromDb(logger = TypoLogger.Noop, ds = ds, viewSelector = Selector.All), Duration.Inf) + val metadb = Await.result(MetaDb.fromDb(logger = TypoLogger.Noop, ds = ds, viewSelector = Selector.All, schemaMode = SchemaMode.MultiSchema), Duration.Inf) val sqlFiles = Await.result(readSqlFileDirectories(TypoLogger.Noop, buildDir.resolve("adventureworks_sql"), ds), Duration.Inf) val crossIds = List( diff --git a/typo-scripts/src/scala/scripts/GeneratedAdventureWorks.scala b/typo-scripts/src/scala/scripts/GeneratedAdventureWorks.scala index 28505875d5..f68cfa9593 100644 --- a/typo-scripts/src/scala/scripts/GeneratedAdventureWorks.scala +++ b/typo-scripts/src/scala/scripts/GeneratedAdventureWorks.scala @@ -27,7 +27,7 @@ object GeneratedAdventureWorks { val ds = TypoDataSource.hikari(server = "localhost", port = 6432, databaseName = "Adventureworks", username = "postgres", password = "password") val scriptsPath = buildDir.resolve("adventureworks_sql") val selector = Selector.ExcludePostgresInternal - val metadb = Await.result(MetaDb.fromDb(TypoLogger.Console, ds, selector), Duration.Inf) + val metadb = Await.result(MetaDb.fromDb(TypoLogger.Console, ds, selector, schemaMode = SchemaMode.MultiSchema), Duration.Inf) val variants = List( (DbLibName.Anorm, JsonLibName.PlayJson, "typo-tester-anorm", new AtomicReference(Map.empty[RelPath, sc.Code])), diff --git a/typo/generated-and-checked-in/typo/generated/custom/constraints/ConstraintsSqlRow.scala b/typo/generated-and-checked-in/typo/generated/custom/constraints/ConstraintsSqlRow.scala index 7d855ab4b0..434344b17f 100644 --- a/typo/generated-and-checked-in/typo/generated/custom/constraints/ConstraintsSqlRow.scala +++ b/typo/generated-and-checked-in/typo/generated/custom/constraints/ConstraintsSqlRow.scala @@ -35,9 +35,8 @@ case class ConstraintsSqlRow( /** Points to [[information_schema.table_constraints.TableConstraintsViewRow.constraintName]] debug: {"baseColumnName":"constraint_name","baseRelationName":"information_schema.table_constraints","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"constraint_name","originalName":"constraint_name"},"columnName":"constraint_name","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"Nullable","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"table_constraints"} */ constraintName: Option[/* nullability unknown */ String], - /** Points to [[information_schema.check_constraints.CheckConstraintsViewRow.checkClause]] - debug: {"baseColumnName":"check_clause","baseRelationName":"information_schema.check_constraints","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"check_clause","originalName":"check_clause"},"columnName":"check_clause","columnType":"VarChar","columnTypeName":"varchar","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"Nullable","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"check_constraints"} */ - checkClause: Option[/* nullability unknown */ String] + /** debug: {"baseColumnName":"check_clause","baseRelationName":"information_schema.check_constraints","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"check_clause","originalName":"check_clause"},"columnName":"check_clause","columnType":"VarChar","columnTypeName":"varchar","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"Nullable","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"check_constraints"} */ + checkClause: Option[String] ) object ConstraintsSqlRow { diff --git a/typo/generated-and-checked-in/typo/generated/custom/domains/DomainsSqlRepoImpl.scala b/typo/generated-and-checked-in/typo/generated/custom/domains/DomainsSqlRepoImpl.scala index c0ae3927f1..7e46836dbf 100644 --- a/typo/generated-and-checked-in/typo/generated/custom/domains/DomainsSqlRepoImpl.scala +++ b/typo/generated-and-checked-in/typo/generated/custom/domains/DomainsSqlRepoImpl.scala @@ -16,7 +16,7 @@ import java.sql.Connection class DomainsSqlRepoImpl extends DomainsSqlRepo { override def apply()(implicit c: Connection): List[DomainsSqlRow] = { val sql = - SQL"""SELECT nsp.nspname as "schema", + SQL"""SELECT nsp.nspname as "schema?", typ.typname as "name", tt.typname as "type", pc.collname as "collation", diff --git a/typo/generated-and-checked-in/typo/generated/custom/domains/DomainsSqlRow.scala b/typo/generated-and-checked-in/typo/generated/custom/domains/DomainsSqlRow.scala index 58f5a2a0f8..97ed8f0992 100644 --- a/typo/generated-and-checked-in/typo/generated/custom/domains/DomainsSqlRow.scala +++ b/typo/generated-and-checked-in/typo/generated/custom/domains/DomainsSqlRow.scala @@ -25,8 +25,8 @@ import scala.util.Try /** SQL file: custom/domains.sql */ case class DomainsSqlRow( /** Points to [[pg_catalog.pg_namespace.PgNamespaceRow.nspname]] - debug: {"baseColumnName":"nspname","baseRelationName":"pg_catalog.pg_namespace","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"schema","originalName":"schema"},"columnName":"schema","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"NoNulls","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"pg_namespace"} */ - schema: String, + debug: {"baseColumnName":"nspname","baseRelationName":"pg_catalog.pg_namespace","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"schema","originalName":"schema?","nullability":"Nullable"},"columnName":"schema?","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"NoNulls","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"pg_namespace"} */ + schema: Option[String], /** Points to [[pg_catalog.pg_type.PgTypeRow.typname]] debug: {"baseColumnName":"typname","baseRelationName":"pg_catalog.pg_type","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"name","originalName":"name"},"columnName":"name","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"NoNulls","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"pg_type"} */ name: String, @@ -53,7 +53,7 @@ object DomainsSqlRow { implicit lazy val reads: Reads[DomainsSqlRow] = Reads[DomainsSqlRow](json => JsResult.fromTry( Try( DomainsSqlRow( - schema = json.\("schema").as(Reads.StringReads), + schema = json.\("schema").toOption.map(_.as(Reads.StringReads)), name = json.\("name").as(Reads.StringReads), `type` = json.\("type").as(Reads.StringReads), collation = json.\("collation").toOption.map(_.as(Reads.StringReads)), @@ -68,7 +68,7 @@ object DomainsSqlRow { def rowParser(idx: Int): RowParser[DomainsSqlRow] = RowParser[DomainsSqlRow] { row => Success( DomainsSqlRow( - schema = row(idx + 0)(Column.columnToString), + schema = row(idx + 0)(Column.columnToOption(Column.columnToString)), name = row(idx + 1)(Column.columnToString), `type` = row(idx + 2)(Column.columnToString), collation = row(idx + 3)(Column.columnToOption(Column.columnToString)), @@ -81,7 +81,7 @@ object DomainsSqlRow { } implicit lazy val writes: OWrites[DomainsSqlRow] = OWrites[DomainsSqlRow](o => new JsObject(ListMap[String, JsValue]( - "schema" -> Writes.StringWrites.writes(o.schema), + "schema" -> Writes.OptionWrites(Writes.StringWrites).writes(o.schema), "name" -> Writes.StringWrites.writes(o.name), "type" -> Writes.StringWrites.writes(o.`type`), "collation" -> Writes.OptionWrites(Writes.StringWrites).writes(o.collation), diff --git a/typo/generated-and-checked-in/typo/generated/custom/enums/EnumsSqlRepoImpl.scala b/typo/generated-and-checked-in/typo/generated/custom/enums/EnumsSqlRepoImpl.scala index 925d563492..fce50f4877 100644 --- a/typo/generated-and-checked-in/typo/generated/custom/enums/EnumsSqlRepoImpl.scala +++ b/typo/generated-and-checked-in/typo/generated/custom/enums/EnumsSqlRepoImpl.scala @@ -16,7 +16,7 @@ import java.sql.Connection class EnumsSqlRepoImpl extends EnumsSqlRepo { override def apply()(implicit c: Connection): List[EnumsSqlRow] = { val sql = - SQL"""select n.nspname as enum_schema, + SQL"""select n.nspname as "enum_schema?", t.typname as enum_name, e.enumsortorder as enum_sort_order, e.enumlabel as enum_value diff --git a/typo/generated-and-checked-in/typo/generated/custom/enums/EnumsSqlRow.scala b/typo/generated-and-checked-in/typo/generated/custom/enums/EnumsSqlRow.scala index 77bb3dd906..6342e95e3a 100644 --- a/typo/generated-and-checked-in/typo/generated/custom/enums/EnumsSqlRow.scala +++ b/typo/generated-and-checked-in/typo/generated/custom/enums/EnumsSqlRow.scala @@ -25,8 +25,8 @@ import scala.util.Try /** SQL file: custom/enums.sql */ case class EnumsSqlRow( /** Points to [[pg_catalog.pg_namespace.PgNamespaceRow.nspname]] - debug: {"baseColumnName":"nspname","baseRelationName":"pg_catalog.pg_namespace","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"enum_schema","originalName":"enum_schema"},"columnName":"enum_schema","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"NoNulls","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"pg_namespace"} */ - enumSchema: String, + debug: {"baseColumnName":"nspname","baseRelationName":"pg_catalog.pg_namespace","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"enum_schema","originalName":"enum_schema?","nullability":"Nullable"},"columnName":"enum_schema?","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"NoNulls","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"pg_namespace"} */ + enumSchema: Option[String], /** Points to [[pg_catalog.pg_type.PgTypeRow.typname]] debug: {"baseColumnName":"typname","baseRelationName":"pg_catalog.pg_type","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"enum_name","originalName":"enum_name"},"columnName":"enum_name","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"NoNulls","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"pg_type"} */ enumName: String, @@ -42,7 +42,7 @@ object EnumsSqlRow { implicit lazy val reads: Reads[EnumsSqlRow] = Reads[EnumsSqlRow](json => JsResult.fromTry( Try( EnumsSqlRow( - enumSchema = json.\("enum_schema").as(Reads.StringReads), + enumSchema = json.\("enum_schema").toOption.map(_.as(Reads.StringReads)), enumName = json.\("enum_name").as(Reads.StringReads), enumSortOrder = json.\("enum_sort_order").as(Reads.FloatReads), enumValue = json.\("enum_value").as(Reads.StringReads) @@ -53,7 +53,7 @@ object EnumsSqlRow { def rowParser(idx: Int): RowParser[EnumsSqlRow] = RowParser[EnumsSqlRow] { row => Success( EnumsSqlRow( - enumSchema = row(idx + 0)(Column.columnToString), + enumSchema = row(idx + 0)(Column.columnToOption(Column.columnToString)), enumName = row(idx + 1)(Column.columnToString), enumSortOrder = row(idx + 2)(Column.columnToFloat), enumValue = row(idx + 3)(Column.columnToString) @@ -62,7 +62,7 @@ object EnumsSqlRow { } implicit lazy val writes: OWrites[EnumsSqlRow] = OWrites[EnumsSqlRow](o => new JsObject(ListMap[String, JsValue]( - "enum_schema" -> Writes.StringWrites.writes(o.enumSchema), + "enum_schema" -> Writes.OptionWrites(Writes.StringWrites).writes(o.enumSchema), "enum_name" -> Writes.StringWrites.writes(o.enumName), "enum_sort_order" -> Writes.FloatWrites.writes(o.enumSortOrder), "enum_value" -> Writes.StringWrites.writes(o.enumValue) diff --git a/typo/generated-and-checked-in/typo/generated/custom/table_comments/TableCommentsSqlRepoImpl.scala b/typo/generated-and-checked-in/typo/generated/custom/table_comments/TableCommentsSqlRepoImpl.scala index c51e83452a..207a22831c 100644 --- a/typo/generated-and-checked-in/typo/generated/custom/table_comments/TableCommentsSqlRepoImpl.scala +++ b/typo/generated-and-checked-in/typo/generated/custom/table_comments/TableCommentsSqlRepoImpl.scala @@ -16,7 +16,7 @@ import java.sql.Connection class TableCommentsSqlRepoImpl extends TableCommentsSqlRepo { override def apply()(implicit c: Connection): List[TableCommentsSqlRow] = { val sql = - SQL"""SELECT n.nspname as schema, + SQL"""SELECT n.nspname as "schema?", c.relname as name, pg_catalog.obj_description(c.oid, 'pg_class') as description FROM pg_catalog.pg_class c diff --git a/typo/generated-and-checked-in/typo/generated/custom/table_comments/TableCommentsSqlRow.scala b/typo/generated-and-checked-in/typo/generated/custom/table_comments/TableCommentsSqlRow.scala index 2f4a1e0720..a39a7fd175 100644 --- a/typo/generated-and-checked-in/typo/generated/custom/table_comments/TableCommentsSqlRow.scala +++ b/typo/generated-and-checked-in/typo/generated/custom/table_comments/TableCommentsSqlRow.scala @@ -25,8 +25,8 @@ import scala.util.Try /** SQL file: custom/table_comments.sql */ case class TableCommentsSqlRow( /** Points to [[pg_catalog.pg_namespace.PgNamespaceRow.nspname]] - debug: {"baseColumnName":"nspname","baseRelationName":"pg_catalog.pg_namespace","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"schema","originalName":"schema"},"columnName":"schema","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"NoNulls","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"pg_namespace"} */ - schema: String, + debug: {"baseColumnName":"nspname","baseRelationName":"pg_catalog.pg_namespace","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"schema","originalName":"schema?","nullability":"Nullable"},"columnName":"schema?","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"NoNulls","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"pg_namespace"} */ + schema: Option[String], /** Points to [[pg_catalog.pg_class.PgClassRow.relname]] debug: {"baseColumnName":"relname","baseRelationName":"pg_catalog.pg_class","columnClassName":"java.lang.String","columnDisplaySize":2147483647,"parsedColumnName":{"name":"name","originalName":"name"},"columnName":"name","columnType":"VarChar","columnTypeName":"name","format":0,"isAutoIncrement":false,"isCaseSensitive":true,"isCurrency":false,"isDefinitelyWritable":false,"isNullable":"NoNulls","isReadOnly":false,"isSearchable":true,"isSigned":false,"isWritable":true,"precision":2147483647,"scale":0,"tableName":"pg_class"} */ name: String, @@ -38,7 +38,7 @@ object TableCommentsSqlRow { implicit lazy val reads: Reads[TableCommentsSqlRow] = Reads[TableCommentsSqlRow](json => JsResult.fromTry( Try( TableCommentsSqlRow( - schema = json.\("schema").as(Reads.StringReads), + schema = json.\("schema").toOption.map(_.as(Reads.StringReads)), name = json.\("name").as(Reads.StringReads), description = json.\("description").toOption.map(_.as(Reads.StringReads)) ) @@ -48,7 +48,7 @@ object TableCommentsSqlRow { def rowParser(idx: Int): RowParser[TableCommentsSqlRow] = RowParser[TableCommentsSqlRow] { row => Success( TableCommentsSqlRow( - schema = row(idx + 0)(Column.columnToString), + schema = row(idx + 0)(Column.columnToOption(Column.columnToString)), name = row(idx + 1)(Column.columnToString), description = row(idx + 2)(Column.columnToOption(Column.columnToString)) ) @@ -56,7 +56,7 @@ object TableCommentsSqlRow { } implicit lazy val writes: OWrites[TableCommentsSqlRow] = OWrites[TableCommentsSqlRow](o => new JsObject(ListMap[String, JsValue]( - "schema" -> Writes.StringWrites.writes(o.schema), + "schema" -> Writes.OptionWrites(Writes.StringWrites).writes(o.schema), "name" -> Writes.StringWrites.writes(o.name), "description" -> Writes.OptionWrites(Writes.StringWrites).writes(o.description) )) diff --git a/typo/generated-and-checked-in/typo/generated/information_schema/CardinalNumber.scala b/typo/generated-and-checked-in/typo/generated/information_schema/CardinalNumber.scala new file mode 100644 index 0000000000..a07841339a --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/information_schema/CardinalNumber.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package information_schema + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `information_schema.cardinal_number` + * Constraint: CHECK ((VALUE >= 0)) + */ +case class CardinalNumber(value: Int) +object CardinalNumber { + implicit lazy val arrayColumn: Column[Array[CardinalNumber]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[CardinalNumber]] = typo.generated.IntArrayToStatement.contramap(_.map(_.value)) + implicit lazy val column: Column[CardinalNumber] = Column.columnToInt.map(CardinalNumber.apply) + implicit lazy val ordering: Ordering[CardinalNumber] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[CardinalNumber] = new ParameterMetaData[CardinalNumber] { + override def sqlType: String = """"information_schema"."cardinal_number"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[CardinalNumber] = Reads.IntReads.map(CardinalNumber.apply) + implicit lazy val text: Text[CardinalNumber] = new Text[CardinalNumber] { + override def unsafeEncode(v: CardinalNumber, sb: StringBuilder) = Text.intInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: CardinalNumber, sb: StringBuilder) = Text.intInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[CardinalNumber] = ToStatement.intToStatement.contramap(_.value) + implicit lazy val writes: Writes[CardinalNumber] = Writes.IntWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/information_schema/CharacterData.scala b/typo/generated-and-checked-in/typo/generated/information_schema/CharacterData.scala new file mode 100644 index 0000000000..8f7a973586 --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/information_schema/CharacterData.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package information_schema + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `information_schema.character_data` + * No constraint + */ +case class CharacterData(value: String) +object CharacterData { + implicit lazy val arrayColumn: Column[Array[CharacterData]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[CharacterData]] = ToStatement.arrayToParameter(ParameterMetaData.StringParameterMetaData).contramap(_.map(_.value)) + implicit lazy val column: Column[CharacterData] = Column.columnToString.map(CharacterData.apply) + implicit lazy val ordering: Ordering[CharacterData] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[CharacterData] = new ParameterMetaData[CharacterData] { + override def sqlType: String = """"information_schema"."character_data"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[CharacterData] = Reads.StringReads.map(CharacterData.apply) + implicit lazy val text: Text[CharacterData] = new Text[CharacterData] { + override def unsafeEncode(v: CharacterData, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: CharacterData, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[CharacterData] = ToStatement.stringToStatement.contramap(_.value) + implicit lazy val writes: Writes[CharacterData] = Writes.StringWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/information_schema/SqlIdentifier.scala b/typo/generated-and-checked-in/typo/generated/information_schema/SqlIdentifier.scala new file mode 100644 index 0000000000..47da285272 --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/information_schema/SqlIdentifier.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package information_schema + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `information_schema.sql_identifier` + * No constraint + */ +case class SqlIdentifier(value: String) +object SqlIdentifier { + implicit lazy val arrayColumn: Column[Array[SqlIdentifier]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[SqlIdentifier]] = ToStatement.arrayToParameter(ParameterMetaData.StringParameterMetaData).contramap(_.map(_.value)) + implicit lazy val column: Column[SqlIdentifier] = Column.columnToString.map(SqlIdentifier.apply) + implicit lazy val ordering: Ordering[SqlIdentifier] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[SqlIdentifier] = new ParameterMetaData[SqlIdentifier] { + override def sqlType: String = """"information_schema"."sql_identifier"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[SqlIdentifier] = Reads.StringReads.map(SqlIdentifier.apply) + implicit lazy val text: Text[SqlIdentifier] = new Text[SqlIdentifier] { + override def unsafeEncode(v: SqlIdentifier, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: SqlIdentifier, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[SqlIdentifier] = ToStatement.stringToStatement.contramap(_.value) + implicit lazy val writes: Writes[SqlIdentifier] = Writes.StringWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/information_schema/TimeStamp.scala b/typo/generated-and-checked-in/typo/generated/information_schema/TimeStamp.scala new file mode 100644 index 0000000000..a5447d7f62 --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/information_schema/TimeStamp.scala @@ -0,0 +1,40 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package information_schema + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes +import typo.generated.customtypes.TypoInstant + +/** Domain `information_schema.time_stamp` + * No constraint + */ +case class TimeStamp(value: TypoInstant) +object TimeStamp { + implicit lazy val arrayColumn: Column[Array[TimeStamp]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[TimeStamp]] = TypoInstant.arrayToStatement.contramap(_.map(_.value)) + implicit lazy val column: Column[TimeStamp] = TypoInstant.column.map(TimeStamp.apply) + implicit def ordering(implicit O0: Ordering[TypoInstant]): Ordering[TimeStamp] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[TimeStamp] = new ParameterMetaData[TimeStamp] { + override def sqlType: String = """"information_schema"."time_stamp"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[TimeStamp] = TypoInstant.reads.map(TimeStamp.apply) + implicit lazy val text: Text[TimeStamp] = new Text[TimeStamp] { + override def unsafeEncode(v: TimeStamp, sb: StringBuilder) = TypoInstant.text.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: TimeStamp, sb: StringBuilder) = TypoInstant.text.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[TimeStamp] = TypoInstant.toStatement.contramap(_.value) + implicit lazy val writes: Writes[TimeStamp] = TypoInstant.writes.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/information_schema/YesOrNo.scala b/typo/generated-and-checked-in/typo/generated/information_schema/YesOrNo.scala new file mode 100644 index 0000000000..3aca8645fb --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/information_schema/YesOrNo.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package information_schema + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `information_schema.yes_or_no` + * Constraint: CHECK (((VALUE)::text = ANY ((ARRAY['YES'::character varying, 'NO'::character varying])::text[]))) + */ +case class YesOrNo(value: String) +object YesOrNo { + implicit lazy val arrayColumn: Column[Array[YesOrNo]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[YesOrNo]] = ToStatement.arrayToParameter(ParameterMetaData.StringParameterMetaData).contramap(_.map(_.value)) + implicit lazy val column: Column[YesOrNo] = Column.columnToString.map(YesOrNo.apply) + implicit lazy val ordering: Ordering[YesOrNo] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[YesOrNo] = new ParameterMetaData[YesOrNo] { + override def sqlType: String = """"information_schema"."yes_or_no"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[YesOrNo] = Reads.StringReads.map(YesOrNo.apply) + implicit lazy val text: Text[YesOrNo] = new Text[YesOrNo] { + override def unsafeEncode(v: YesOrNo, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: YesOrNo, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[YesOrNo] = ToStatement.stringToStatement.contramap(_.value) + implicit lazy val writes: Writes[YesOrNo] = Writes.StringWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/pg_catalog/pg_namespace/PgNamespaceRow.scala b/typo/generated-and-checked-in/typo/generated/pg_catalog/pg_namespace/PgNamespaceRow.scala index d569ba795e..bcf00dd695 100644 --- a/typo/generated-and-checked-in/typo/generated/pg_catalog/pg_namespace/PgNamespaceRow.scala +++ b/typo/generated-and-checked-in/typo/generated/pg_catalog/pg_namespace/PgNamespaceRow.scala @@ -25,13 +25,13 @@ import typo.generated.customtypes.TypoAclItem /** Table: pg_catalog.pg_namespace */ case class PgNamespaceRow( - /** debug: {"table_catalog":"postgres","table_schema":"pg_catalog","table_name":"pg_namespace","column_name":"oid","ordinal_position":1,"is_nullable":"NO","data_type":"oid","udt_catalog":"postgres","udt_schema":"pg_catalog","udt_name":"oid","dtd_identifier":"1","is_self_referencing":"NO","is_identity":"NO","identity_cycle":"NO","is_generated":"NEVER","is_updatable":"YES"} */ + /** debug: {"table_catalog":"Adventureworks","table_schema":"pg_catalog","table_name":"pg_namespace","column_name":"oid","ordinal_position":1,"is_nullable":"NO","data_type":"oid","udt_catalog":"Adventureworks","udt_schema":"pg_catalog","udt_name":"oid","dtd_identifier":"1","is_self_referencing":"NO","is_identity":"NO","identity_cycle":"NO","is_generated":"NEVER","is_updatable":"YES"} */ oid: /* oid */ Long, - /** debug: {"table_catalog":"postgres","table_schema":"pg_catalog","table_name":"pg_namespace","column_name":"nspname","ordinal_position":2,"is_nullable":"NO","data_type":"name","collation_catalog":"postgres","collation_schema":"pg_catalog","collation_name":"C","udt_catalog":"postgres","udt_schema":"pg_catalog","udt_name":"name","dtd_identifier":"2","is_self_referencing":"NO","is_identity":"NO","identity_cycle":"NO","is_generated":"NEVER","is_updatable":"YES"} */ + /** debug: {"table_catalog":"Adventureworks","table_schema":"pg_catalog","table_name":"pg_namespace","column_name":"nspname","ordinal_position":2,"is_nullable":"NO","data_type":"name","collation_catalog":"Adventureworks","collation_schema":"pg_catalog","collation_name":"C","udt_catalog":"Adventureworks","udt_schema":"pg_catalog","udt_name":"name","dtd_identifier":"2","is_self_referencing":"NO","is_identity":"NO","identity_cycle":"NO","is_generated":"NEVER","is_updatable":"YES"} */ nspname: String, - /** debug: {"table_catalog":"postgres","table_schema":"pg_catalog","table_name":"pg_namespace","column_name":"nspowner","ordinal_position":3,"is_nullable":"NO","data_type":"oid","udt_catalog":"postgres","udt_schema":"pg_catalog","udt_name":"oid","dtd_identifier":"3","is_self_referencing":"NO","is_identity":"NO","identity_cycle":"NO","is_generated":"NEVER","is_updatable":"YES"} */ + /** debug: {"table_catalog":"Adventureworks","table_schema":"pg_catalog","table_name":"pg_namespace","column_name":"nspowner","ordinal_position":3,"is_nullable":"NO","data_type":"oid","udt_catalog":"Adventureworks","udt_schema":"pg_catalog","udt_name":"oid","dtd_identifier":"3","is_self_referencing":"NO","is_identity":"NO","identity_cycle":"NO","is_generated":"NEVER","is_updatable":"YES"} */ nspowner: /* oid */ Long, - /** debug: {"table_catalog":"postgres","table_schema":"pg_catalog","table_name":"pg_namespace","column_name":"nspacl","ordinal_position":4,"is_nullable":"YES","data_type":"ARRAY","udt_catalog":"postgres","udt_schema":"pg_catalog","udt_name":"_aclitem","dtd_identifier":"4","is_self_referencing":"NO","is_identity":"NO","identity_cycle":"NO","is_generated":"NEVER","is_updatable":"YES"} */ + /** debug: {"table_catalog":"Adventureworks","table_schema":"pg_catalog","table_name":"pg_namespace","column_name":"nspacl","ordinal_position":4,"is_nullable":"YES","data_type":"ARRAY","udt_catalog":"Adventureworks","udt_schema":"pg_catalog","udt_name":"_aclitem","dtd_identifier":"4","is_self_referencing":"NO","is_identity":"NO","identity_cycle":"NO","is_generated":"NEVER","is_updatable":"YES"} */ nspacl: Option[Array[TypoAclItem]] ) diff --git a/typo/generated-and-checked-in/typo/generated/public/AccountNumber.scala b/typo/generated-and-checked-in/typo/generated/public/AccountNumber.scala new file mode 100644 index 0000000000..938b81d600 --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/public/AccountNumber.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package public + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `public.AccountNumber` + * No constraint + */ +case class AccountNumber(value: String) +object AccountNumber { + implicit lazy val arrayColumn: Column[Array[AccountNumber]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[AccountNumber]] = ToStatement.arrayToParameter(ParameterMetaData.StringParameterMetaData).contramap(_.map(_.value)) + implicit lazy val column: Column[AccountNumber] = Column.columnToString.map(AccountNumber.apply) + implicit lazy val ordering: Ordering[AccountNumber] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[AccountNumber] = new ParameterMetaData[AccountNumber] { + override def sqlType: String = """"public"."AccountNumber"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[AccountNumber] = Reads.StringReads.map(AccountNumber.apply) + implicit lazy val text: Text[AccountNumber] = new Text[AccountNumber] { + override def unsafeEncode(v: AccountNumber, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: AccountNumber, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[AccountNumber] = ToStatement.stringToStatement.contramap(_.value) + implicit lazy val writes: Writes[AccountNumber] = Writes.StringWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/public/Flag.scala b/typo/generated-and-checked-in/typo/generated/public/Flag.scala new file mode 100644 index 0000000000..1efe199c73 --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/public/Flag.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package public + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `public.Flag` + * No constraint + */ +case class Flag(value: Boolean) +object Flag { + implicit lazy val arrayColumn: Column[Array[Flag]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[Flag]] = typo.generated.BooleanArrayToStatement.contramap(_.map(_.value)) + implicit lazy val column: Column[Flag] = Column.columnToBoolean.map(Flag.apply) + implicit lazy val ordering: Ordering[Flag] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[Flag] = new ParameterMetaData[Flag] { + override def sqlType: String = """"public"."Flag"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[Flag] = Reads.BooleanReads.map(Flag.apply) + implicit lazy val text: Text[Flag] = new Text[Flag] { + override def unsafeEncode(v: Flag, sb: StringBuilder) = Text.booleanInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: Flag, sb: StringBuilder) = Text.booleanInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[Flag] = ToStatement.booleanToStatement.contramap(_.value) + implicit lazy val writes: Writes[Flag] = Writes.BooleanWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/public/Mydomain.scala b/typo/generated-and-checked-in/typo/generated/public/Mydomain.scala new file mode 100644 index 0000000000..244ac461cd --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/public/Mydomain.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package public + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `public.mydomain` + * No constraint + */ +case class Mydomain(value: String) +object Mydomain { + implicit lazy val arrayColumn: Column[Array[Mydomain]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[Mydomain]] = ToStatement.arrayToParameter(ParameterMetaData.StringParameterMetaData).contramap(_.map(_.value)) + implicit lazy val column: Column[Mydomain] = Column.columnToString.map(Mydomain.apply) + implicit lazy val ordering: Ordering[Mydomain] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[Mydomain] = new ParameterMetaData[Mydomain] { + override def sqlType: String = """"public"."mydomain"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[Mydomain] = Reads.StringReads.map(Mydomain.apply) + implicit lazy val text: Text[Mydomain] = new Text[Mydomain] { + override def unsafeEncode(v: Mydomain, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: Mydomain, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[Mydomain] = ToStatement.stringToStatement.contramap(_.value) + implicit lazy val writes: Writes[Mydomain] = Writes.StringWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/public/Name.scala b/typo/generated-and-checked-in/typo/generated/public/Name.scala new file mode 100644 index 0000000000..a97e57a759 --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/public/Name.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package public + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `public.Name` + * No constraint + */ +case class Name(value: String) +object Name { + implicit lazy val arrayColumn: Column[Array[Name]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[Name]] = ToStatement.arrayToParameter(ParameterMetaData.StringParameterMetaData).contramap(_.map(_.value)) + implicit lazy val column: Column[Name] = Column.columnToString.map(Name.apply) + implicit lazy val ordering: Ordering[Name] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[Name] = new ParameterMetaData[Name] { + override def sqlType: String = """"public"."Name"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[Name] = Reads.StringReads.map(Name.apply) + implicit lazy val text: Text[Name] = new Text[Name] { + override def unsafeEncode(v: Name, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: Name, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[Name] = ToStatement.stringToStatement.contramap(_.value) + implicit lazy val writes: Writes[Name] = Writes.StringWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/public/NameStyle.scala b/typo/generated-and-checked-in/typo/generated/public/NameStyle.scala new file mode 100644 index 0000000000..a6e3928af8 --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/public/NameStyle.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package public + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `public.NameStyle` + * No constraint + */ +case class NameStyle(value: Boolean) +object NameStyle { + implicit lazy val arrayColumn: Column[Array[NameStyle]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[NameStyle]] = typo.generated.BooleanArrayToStatement.contramap(_.map(_.value)) + implicit lazy val column: Column[NameStyle] = Column.columnToBoolean.map(NameStyle.apply) + implicit lazy val ordering: Ordering[NameStyle] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[NameStyle] = new ParameterMetaData[NameStyle] { + override def sqlType: String = """"public"."NameStyle"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[NameStyle] = Reads.BooleanReads.map(NameStyle.apply) + implicit lazy val text: Text[NameStyle] = new Text[NameStyle] { + override def unsafeEncode(v: NameStyle, sb: StringBuilder) = Text.booleanInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: NameStyle, sb: StringBuilder) = Text.booleanInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[NameStyle] = ToStatement.booleanToStatement.contramap(_.value) + implicit lazy val writes: Writes[NameStyle] = Writes.BooleanWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/public/OrderNumber.scala b/typo/generated-and-checked-in/typo/generated/public/OrderNumber.scala new file mode 100644 index 0000000000..b41bcbad3c --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/public/OrderNumber.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package public + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `public.OrderNumber` + * No constraint + */ +case class OrderNumber(value: String) +object OrderNumber { + implicit lazy val arrayColumn: Column[Array[OrderNumber]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[OrderNumber]] = ToStatement.arrayToParameter(ParameterMetaData.StringParameterMetaData).contramap(_.map(_.value)) + implicit lazy val column: Column[OrderNumber] = Column.columnToString.map(OrderNumber.apply) + implicit lazy val ordering: Ordering[OrderNumber] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[OrderNumber] = new ParameterMetaData[OrderNumber] { + override def sqlType: String = """"public"."OrderNumber"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[OrderNumber] = Reads.StringReads.map(OrderNumber.apply) + implicit lazy val text: Text[OrderNumber] = new Text[OrderNumber] { + override def unsafeEncode(v: OrderNumber, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: OrderNumber, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[OrderNumber] = ToStatement.stringToStatement.contramap(_.value) + implicit lazy val writes: Writes[OrderNumber] = Writes.StringWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/public/Phone.scala b/typo/generated-and-checked-in/typo/generated/public/Phone.scala new file mode 100644 index 0000000000..cdd8fc7e11 --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/public/Phone.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package public + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `public.Phone` + * No constraint + */ +case class Phone(value: String) +object Phone { + implicit lazy val arrayColumn: Column[Array[Phone]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[Phone]] = ToStatement.arrayToParameter(ParameterMetaData.StringParameterMetaData).contramap(_.map(_.value)) + implicit lazy val column: Column[Phone] = Column.columnToString.map(Phone.apply) + implicit lazy val ordering: Ordering[Phone] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[Phone] = new ParameterMetaData[Phone] { + override def sqlType: String = """"public"."Phone"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[Phone] = Reads.StringReads.map(Phone.apply) + implicit lazy val text: Text[Phone] = new Text[Phone] { + override def unsafeEncode(v: Phone, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: Phone, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[Phone] = ToStatement.stringToStatement.contramap(_.value) + implicit lazy val writes: Writes[Phone] = Writes.StringWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/generated-and-checked-in/typo/generated/public/ShortText.scala b/typo/generated-and-checked-in/typo/generated/public/ShortText.scala new file mode 100644 index 0000000000..532ab675bc --- /dev/null +++ b/typo/generated-and-checked-in/typo/generated/public/ShortText.scala @@ -0,0 +1,39 @@ +/** + * File has been automatically generated by `typo` for internal use. + * + * IF YOU CHANGE THIS FILE YOUR CHANGES WILL BE OVERWRITTEN. + * + * (If you're developing `typo` and want to change it: run `bleep generate-sources`) + */ +package typo +package generated +package public + +import anorm.Column +import anorm.ParameterMetaData +import anorm.ToStatement +import java.sql.Types +import play.api.libs.json.Reads +import play.api.libs.json.Writes + +/** Domain `public.short_text` + * Constraint: CHECK ((length(VALUE) <= 55)) + */ +case class ShortText(value: String) +object ShortText { + implicit lazy val arrayColumn: Column[Array[ShortText]] = Column.columnToArray(column, implicitly) + implicit lazy val arrayToStatement: ToStatement[Array[ShortText]] = ToStatement.arrayToParameter(ParameterMetaData.StringParameterMetaData).contramap(_.map(_.value)) + implicit lazy val column: Column[ShortText] = Column.columnToString.map(ShortText.apply) + implicit lazy val ordering: Ordering[ShortText] = Ordering.by(_.value) + implicit lazy val parameterMetadata: ParameterMetaData[ShortText] = new ParameterMetaData[ShortText] { + override def sqlType: String = """"public"."short_text"""" + override def jdbcType: Int = Types.OTHER + } + implicit lazy val reads: Reads[ShortText] = Reads.StringReads.map(ShortText.apply) + implicit lazy val text: Text[ShortText] = new Text[ShortText] { + override def unsafeEncode(v: ShortText, sb: StringBuilder) = Text.stringInstance.unsafeEncode(v.value, sb) + override def unsafeArrayEncode(v: ShortText, sb: StringBuilder) = Text.stringInstance.unsafeArrayEncode(v.value, sb) + } + implicit lazy val toStatement: ToStatement[ShortText] = ToStatement.stringToStatement.contramap(_.value) + implicit lazy val writes: Writes[ShortText] = Writes.StringWrites.contramap(_.value) +} \ No newline at end of file diff --git a/typo/src/scala/typo/MetaDb.scala b/typo/src/scala/typo/MetaDb.scala index 950fddf0d0..467a4c4dd8 100644 --- a/typo/src/scala/typo/MetaDb.scala +++ b/typo/src/scala/typo/MetaDb.scala @@ -39,7 +39,48 @@ object MetaDb { columnComments: List[CommentsSqlRow], constraints: List[ConstraintsSqlRow], tableComments: List[TableCommentsSqlRow] - ) + ) { + def filter(schemaMode: SchemaMode): Input = { + schemaMode match { + case SchemaMode.MultiSchema => this + case SchemaMode.SingleSchema(wantedSchema) => + def keep(os: Option[String]): Boolean = os.contains(wantedSchema) + + Input( + tableConstraints = tableConstraints.collect { + case x if keep(x.tableSchema) || keep(x.constraintSchema) => + x.copy(tableSchema = None, constraintSchema = None) + }, + keyColumnUsage = keyColumnUsage.collect { + case x if keep(x.tableSchema) || keep(x.constraintSchema) => + x.copy(tableSchema = None, constraintSchema = None) + }, + referentialConstraints = referentialConstraints.collect { + case x if keep(x.constraintSchema) => + x.copy(constraintSchema = None) + }, + pgEnums = pgEnums.collect { case x if keep(x.enumSchema) => x.copy(enumSchema = None) }, + tables = tables.collect { case x if keep(x.tableSchema) => x.copy(tableSchema = None) }, + columns = columns.collect { + case x if keep(x.tableSchema) => + x.copy( + tableSchema = None, + characterSetSchema = None, + collationSchema = None, + domainSchema = None, + udtSchema = None, + scopeSchema = None + ) + }, + views = views.collect { case (k, v) if keep(k.schema) => k.copy(schema = None) -> v.copy(row = v.row.copy(tableSchema = None)) }, + domains = domains.collect { case x if keep(x.schema) => x.copy(schema = None) }, + columnComments = columnComments.collect { case c if keep(c.tableSchema) => c.copy(tableSchema = None) }, + constraints = constraints.collect { case c if keep(c.tableSchema) => c.copy(tableSchema = None) }, + tableComments = tableComments.collect { case c if keep(c.schema) => c.copy(schema = None) } + ) + } + } + } case class AnalyzedView( row: ViewFindAllSqlRow, @@ -49,7 +90,7 @@ object MetaDb { ) object Input { - def fromDb(logger: TypoLogger, ds: TypoDataSource, viewSelector: Selector)(implicit ev: ExecutionContext): Future[Input] = { + def fromDb(logger: TypoLogger, ds: TypoDataSource, viewSelector: Selector, schemaMode: SchemaMode)(implicit ev: ExecutionContext): Future[Input] = { val tableConstraints = logger.timed("fetching tableConstraints")(ds.run(implicit c => (new TableConstraintsViewRepoImpl).selectAll)) val keyColumnUsage = logger.timed("fetching keyColumnUsage")(ds.run(implicit c => (new KeyColumnUsageViewRepoImpl).selectAll)) val referentialConstraints = logger.timed("fetching referentialConstraints")(ds.run(implicit c => (new ReferentialConstraintsViewRepoImpl).selectAll)) @@ -92,24 +133,28 @@ object MetaDb { columnComments <- columnComments constraints <- constraints tableComments <- tableComments - } yield Input( - tableConstraints, - keyColumnUsage, - referentialConstraints, - pgEnums, - tables, - columns, - views, - domains, - columnComments, - constraints, - tableComments - ) + } yield { + val input = Input( + tableConstraints, + keyColumnUsage, + referentialConstraints, + pgEnums, + tables, + columns, + views, + domains, + columnComments, + constraints, + tableComments + ) + // todo: do this at SQL level instead for performance + input.filter(schemaMode) + } } } - def fromDb(logger: TypoLogger, ds: TypoDataSource, viewSelector: Selector)(implicit ec: ExecutionContext): Future[MetaDb] = - Input.fromDb(logger, ds, viewSelector).map(input => fromInput(logger, input)) + def fromDb(logger: TypoLogger, ds: TypoDataSource, viewSelector: Selector, schemaMode: SchemaMode)(implicit ec: ExecutionContext): Future[MetaDb] = + Input.fromDb(logger, ds, viewSelector, schemaMode: SchemaMode).map(input => fromInput(logger, input)) def fromInput(logger: TypoLogger, input: Input): MetaDb = { val foreignKeys = ForeignKeys(input.tableConstraints, input.keyColumnUsage, input.referentialConstraints) @@ -123,7 +168,7 @@ object MetaDb { } db.Domain( - name = db.RelationName(Some(d.schema), d.name), + name = db.RelationName(d.schema, d.name), tpe = tpe, originalType = d.`type`, isNotNull = if (d.isNotNull) Nullability.NoNulls else Nullability.Nullable, @@ -153,7 +198,7 @@ object MetaDb { val columnsByTable: Map[db.RelationName, List[ColumnsViewRow]] = input.columns.groupBy(c => db.RelationName(c.tableSchema, c.tableName.get)) val tableCommentsByTable: Map[db.RelationName, String] = - input.tableComments.flatMap(c => c.description.map(d => (db.RelationName(Some(c.schema), c.name), d))).toMap + input.tableComments.flatMap(c => c.description.map(d => (db.RelationName(c.schema, c.name), d))).toMap val views: Map[db.RelationName, Lazy[db.View]] = input.views.map { case (relationName, AnalyzedView(viewRow, decomposedSql, jdbcMetadata, nullabilityAnalysis)) => val lazyAnalysis = Lazy { diff --git a/typo/src/scala/typo/Options.scala b/typo/src/scala/typo/Options.scala index 3b9badeb9a..ae4accc8cf 100644 --- a/typo/src/scala/typo/Options.scala +++ b/typo/src/scala/typo/Options.scala @@ -24,7 +24,8 @@ case class Options( fixVerySlowImplicit: Boolean = true, keepDependencies: Boolean = false, rewriteDatabase: MetaDb => MetaDb = identity, - executionContext: ExecutionContext = ExecutionContext.global + executionContext: ExecutionContext = ExecutionContext.global, + schemaMode: SchemaMode = SchemaMode.MultiSchema ) object Options { diff --git a/typo/src/scala/typo/generateFromDb.scala b/typo/src/scala/typo/generateFromDb.scala index 0ad1d8c07c..ff722283a9 100644 --- a/typo/src/scala/typo/generateFromDb.scala +++ b/typo/src/scala/typo/generateFromDb.scala @@ -32,7 +32,7 @@ object generateFromDb { Banner.maybePrint(options) implicit val ec: ExecutionContext = options.executionContext val viewSelector = graph.toList.map(_.value).foldLeft(Selector.None)(_.or(_)) - val eventualMetaDb = MetaDb.fromDb(options.logger, dataSource, viewSelector) + val eventualMetaDb = MetaDb.fromDb(options.logger, dataSource, viewSelector, options.schemaMode) val eventualScripts = graph.mapScripts(paths => Future.sequence(paths.map(p => readSqlFileDirectories(options.logger, p, dataSource))).map(_.flatten)) val combined = for { metaDb <- eventualMetaDb diff --git a/typo/src/scala/typo/internal/metadb/Enums.scala b/typo/src/scala/typo/internal/metadb/Enums.scala index a830249a46..b1083c1f37 100644 --- a/typo/src/scala/typo/internal/metadb/Enums.scala +++ b/typo/src/scala/typo/internal/metadb/Enums.scala @@ -7,7 +7,7 @@ import typo.generated.custom.enums.EnumsSqlRow object Enums { def apply(pgEnums: List[EnumsSqlRow]): List[db.StringEnum] = { pgEnums - .groupBy(row => db.RelationName(Some(row.enumSchema), row.enumName)) + .groupBy(row => db.RelationName(row.enumSchema, row.enumName)) .map { case (relName, values: Seq[EnumsSqlRow]) => db.StringEnum(relName, values.sortBy(_.enumSortOrder).map(_.enumValue)) }