v0.33.0

Added

• Added support to generate code for INSERT queries in bobgen-psql.
• clause.Confict now takes bob.Expression, and the fields are now moved to a clause.ConflictClause struct.

Changed

• Make grouped types in generated queries a type alias.

Removed

• Remove models.InsertWhere in generated code since it is not correct.

Fixed

• Fix issue with column query annotations in bobgen-psql.
• Fix issue with parsing multiple queries in the same file in bobgen-psql.
• Fix issue with correctly detecting the comment for the query annotation in bobgen-psql.
• Use a transaction in generated query tests.
• Account for LEFT, RIGHT and FULL joins when determining the nullability of a column.
• Generate WHERE helpers for ON CONFLICT clauses.

Full Changelog: v0.32.0...v0.33.0

v0.32.0

Added

• Added templates for query generation.
• Added clause.OrderBy.ClearOrderBy()
• Added expr.ToArgs and expr.ToArgGroup functions to convert slices of a type to args.
• Add queries key to bobgen-sql and bobgen-sqlite configuration. This is used to specify what folder to search for queries in.
• Implement the Postgres query parser for SELECT statements.
• Implement the SQLite query parser for SELECT statements.
• Add templates for query generation.
• Add camelCase template function.
• Add types to the orm package to be used in generated queries. orm.ArgWithPosition, orm.ModExpression, orm.ModExecQuery and orm.ModQuery.
• Add function orm.ArgsToExpression for use in the generated code.
• Add String() method to bob.QueryType

Fixed

• Update mvdan.cc/gofumpt and give precedence to toolchain when calculating the Go version. (thanks @isgj)
• Add custom comparison support when loading relationships.
• Fix issue with scanning Postgres inet type.
• Set Arg and ArgGroup to NULL if there are no values.
• Do not call BeforeInsertHooks in the insert mod of a view.
• Fix issue with retrieving inserted rows with the MySQL driver.
• Add custom comparison for relationship loading. (thanks @kostaspt)

Changed

• clause.With now takes bob.Expression instead of clause.CTE. This makes it easier to use in generated queries without reconstruction an CTE.
• clause.OrderBy now takes bob.Expression instead of clause.OrderDef. This makes it easier to use in generated queries without reconstruction an OrderDef.
• clause.Windows now takes bob.Expression instead of clause.NamedWindow. This makes it easier to use in generated queries without reconstruction the window.
• clause.For renemaed to clause.Locks and can now take multiple locks.
• clause.Fetch now takes any instead of an integer.
• Several changes to the drivers.Query type as support is added for the new query parser.
• Enum types can now be matched by db_type in bobgen-psql as schema.enum_type. (thanks @abramlab)

Removed

• Removed clause.OrderBy.SetOrderBy() as it was only being used to clear the set order by clauses.

New Contributors

• @kostaspt made their first contribution in #384
• @abramlab made their first contribution in #390

Full Changelog: v0.31.0...v0.32.0

v0.31.0

Added

• Added support for libSQL. (thanks @mbezhanov)
• Added support for declaring types inside the models package. (thanks @jacobmolby)

Changed

• Generates error constants with unique indexes instead of unique constraints. (thanks @tlietz)

Fixed

• Used Equal method for comparing decimals. (thanks @jalaziz)
• Update golang.org/x/mod dependency to enable parsing of Go 1.23 modules. (thanks @m110)

New Contributors

• @tlietz made their first contribution in #360
• @jalaziz made their first contribution in #374
• @m110 made their first contribution in #358

Full Changelog: v0.30.0...v0.31.0

v0.30.0

Added

• Added a new field QueryFolders to gen/drivers.DBInfo for drivers to be able to include information about parsed queries.
• Added gen/QueriesTemplates which in the future will contain base templates for generating code for parsed qureries.
• Added a QueryTemplate field to bobgen_helpers.Templates for drivers to include additional templates for queries.
• Added a new reserved output key queries. This is handled specially for each query folder supplied by the driver.
• Added new wm package to each dialect for mods that modify Window clauses.
• Added a new method Alias for View struct, for each dialect. It returns the alias of the view. (thanks @Nitjsefni7)

Changed

• Updated error constant generation to employ specific error types for making error matching easier. (thanks @mbezhanov)
• Collation in clause.OrderDef is now a string not an expression and is always quoted
• Calling UpdateAll, DeleteAll and ReloadAll on an empty model slice now returns nil without running any queries.
• UNION, INTERSECT and EXCEPT mods now append to the query instead of replacing it.
• Generated files now end with .bob.go instead of .go and are always cleaned up before generating new files. Singleton templates are now required to have a .bob.go.tpl extension.
• The expected structure for templates have been changed:
  • Previously, singleton templates should be kept in a singleton folder. Now, any template not inside a folder is considered a singleton template.
  • Previoulsy, templates in the root folder are merged and run for each table. Now, this will happen to templates in the table/ folder.
  • Previoulsy, the entire file tree and every subdirectory is walked to find templates. Now only templates in the root folder and the table/ folder are considered.
• Change From in clause.Window to BasedOn to avoid confusion with FromPreceding and FromFollowing. Also change SetFrom to SetBasedOn.
• Embed clause.OrderBy in clause.Window to make it possible to reuse OrderBy mods in window definitions.
• Change the Definition field in clause.NamedWindow from any to clause.Window for extra type safety.
• sm.Window now takes mods to modify the window clause.
• fm.Over now takes mods to modify the window for the window function.

Deprecated

• Deprecated the wipe option to delete all files in the output folder. Files are now generated with a .bob.go extension and are always cleaned up before generating new files.

Removed

• Remove redundatnt type parameters from orm.ExecQuery.
• Remove unnecessary interface in orm.Query and orm.ExecQuery.
• Remove the redundant clause.IWindow interface.
• Remove dialect.WindowMod and dialect.WindowMods which use chainable methods to modify Window clauses. This is now handled by the wm package which used mods.

Fixed

• Fix random value generation for pq.Float64Array factory (thanks @felipeparaujo)
• Using the UpdateMod() and DeleteMod() methods on an empty model slice now appends WHERE primary_key IN NULL which will return no results. Instead of WHERE primary_key IN () which is a syntax error.
• Ensure net/netip is imported for the pgtypes.Inet random expression (thanks @plunkettscott)
• Fix a data race when adding enum types.
• Fix missing schema in table alias in pkEQ and pkIN clauses (thanks @adatob).

New Contributors

• @felipeparaujo made their first contribution in #321
• @plunkettscott made their first contribution in #328
• @adatob made their first contribution in #327
• @Nitjsefni7 made their first contribution in #339

Full Changelog: v0.29.0...v0.30.0

v0.29.0

Added

• Added error constants for matching against both specific and generic unique constraint errors raised by the underlying database driver. (thanks @mbezhanov)
• Added support for regular expressions in the only and except table filters. (thanks @mbezhanov)
• Added ContextualMods which are similar to regular mods but take a context argument. They are applied whenever the query is built.
  This makes it cleaner to do certain things, like populating the select columns of a model if none was explicitly added.
  The previous way this was done was unreliable since using q.MustBuild() would not add the columns while bob.MustBuild(q) will add them correctly.
• modelSlice.UpdateMod() and modelSlice.DeleteMod() are new methods that returns a mod for update and delete queries on a slice of models.
  It adds WHERE pk IN (pk1, pk2, pk3, ...) to the query, and also schedule running the hooks.
• Added bob.ToMods which a slice of structs that implement bob.Mod[T] to a Mod. This is useful since Go does not allow using a slice of structs as a slice of an interface the struct implements.
• Added bob.HookableQuery interface. If a query implements this interface, the method RunHooks(ctx, exec) will be called before the query is executed.
• Added bob.HookableType interface. If a type implements this interface, the method AfterQueryHook(ctx, exec, bob.QueryType) will be called after the query is executed.
  This is how AfterSeleect/Insert/Update/DeleteHooks hooks are now implemented.
• Added Type() QueryType method to bob.Query to get the type of query it is. Available constants are Unknown, Select, Insert, Update, Delete.
• Postgres and SQLite Update/Delete queries now refresh the models after the query is executed. This is enabled by the RETURNING clause, so it is not available in MySQL.
• Added the Case() starter to all dialects to build CASE expressions. (thanks @k4n4ry)
• Added bob.Named() which is used to add named arguments to the query and bind them later.
• Added bob.BindNamed which takes an argument (struct, map, or a single value type) to be used to bind named arguments in a query. See changes to bob.Prepare() for details of which type can be used.
• Indexes now include more information such as the type, unique and comment fields.
• Constraints now include a comment field.
• Added Checks field to DBConstraints so that drivers can also load check constraints. (not yet supported by the SQLite driver).
• Added comments field to Table definitions.

Changed

• context.Context is now passed to Query.WriteQuery() and Expression.WriteSQL() methods. This allows for more control over how the query is built and executed.
  This change made is possible to delete some hacks and simplify the codebase.

  • The Name() and NameAs() methods of Views/Tables no longer need the context argument since the context will be passed when writing the expression. The API then becomes cleaner.
  • Preloading mods no longer need to store a context internally. SetLoadContext() and GetLoadContext() have removed.
  • The ToExpr field in orm.RelSide which was used for preloading is no longer needed and has been removed.

• Moved orm.Hooks to bob.Hooks since it should not be limited to only ORM queries.

• Moved mods.QueryModFunc to bob.ModFunc since it should be available to all packages.

• The mod capability for orm.Setter is now reversed. It should now be a mod for Insert and have a method that returns a mod for Update.
  This makes more sense since one would at most use one setter during updates, but can use multiple setters in a bulk insert.

• table.InsertQ has been renamed to table.Insert. The old implementation of Insert has been removed.
  The same functionality can be achieved in the following way:

  //----------------------------------------------
  // OLD WAY
  //----------------------------------------------
  user, err := models.Users.Insert(ctx, db, setter) // insert one
  users, err := models.Users.InsertMany(ctx, db, setters...) // insert many
  
  //----------------------------------------------
  // NEW WAY
  //----------------------------------------------
  user, err := models.Users.Insert(setter).One(ctx, db) // insert one
  users, err := models.Users.Insert(setters[0], setters[1]).All(ctx, db) // insert many
  
  // For cases where you already have a slice of setters and you want to pass them all, you can use `bob.ToMods`
  users, err := models.Users.Insert(bob.ToMods(setters)).All(ctx, db) // insert many

• table.UpdateQ has been renamed to table.Update. The old implementation of Update has been removed.
  The same functionality can be achieved by using model.Update() or modelSlice.UpdateAll().

• table.DeleteQ has been renamed to table.Delete. The old implementation of Delete has been removed.
  The same functionality can be achieved by using modelSlice.DeleteAll() or creating an Delete query using table.Delete().

• BeforeInsertHooks now only takes a single ModelSetter at a time.
  This is because it is not possible to know before executing the queries exactly how many setters are being used since additional rows can be inserted by applying another setter as a mod.

• bob.Cache() now requires an Executor. This is used to run any query hooks.

• bob.Prepare() now requires a type parameter to be used to bind named arguments. The type can either be:

  • A struct with fields that match the named arguments in the query
  • A map with string keys. When supplied, the values in the map will be used to bind the named arguments in the query.
  • When there is only a single named argument, one of the following can be used:
    • A primitive type (int, bool, string, etc)
    • time.Time
    • Any type that implements driver.Valuer.

• Index columns are no longer just strings, but are a struct to include more information such as the sort order.

Removed

• Remove MS SQL artifacts. (thanks @mbezhanov)
• Remove redundant type parameter from bob.Load.
• Removed Before/AfterUpsertMods. Upserts are really just inserts with a conflict clause and should be treated as such.
• Removed Insert/InsertMany/Upsert/UpsertMany methods from orm.Table since they are not needed.
  It is possible to do the same thing, with similar effor using the the InsertQ method (which is now renamed to Insert).
• Remove Update and Delete methods from orm.Table since they are not needed.
  It is possible to do the same thing, with similar effor using the the UpdateQ and DeleteQ methods (which are now renamed to Update and Delete).
• context.Context and bob.Executor are no longer passed when creating a Table/ViewQuery. It is now passed at the point of execution with Exec/One/All/Cursor.
• Remove Prepare methods from table and view qureries. Since bob.Prepare() now takes a type parameter, it is not possible to prepare from a method since Go does not allow additional type parameters in methods.
• Removed the Prisma and Atlas code generation drivers. It is better for Bob to focus on being able to generate code from the database in the most robust and detailed way and if the user wants, they can use other tools (such as prisma and atlas) to manage migrations before the code generation.
• Removed Expressions from Index definitions. It is now merged with the Columns field with an IsExpression field to indicate if the column is an expression.

Fixed

• Removed unnecessary import of strings in bobfactory_random.go.
• Fixed data races in unit tests. (thanks @mbezhanov)
• Fixed invalid SQL statements generated by sm.OrderBy().Collate(). (thanks @mbezhanov)
• Fixed a bug preventing specific columns from being excluded when generating models from SQLite. (thanks @mbezhanov)
• Fixed an issue where invalid code is generated if a configured relationship has from_where or to_where.
• Fixed ModelSlice.ReloadAll() method for models with multiple primary keys.

New Contributors

• @tjmtmmnk made their first contribution in #247
• @adel-hadadi made their first contribution in #249
• @Hasaber8 made their first contribution in #265
• @mrtztg made their first contribution in #272
• @k4n4ry made their first contribution in #294

Full Changelog: v0.28.1...v0.29.0

v0.28.1

Fixed

• Also add the enum to the type array if an array of the enum is added. This is to prvent issues if the enum is only used in an array.
• Handle null column names in expression indexes. (thanks @mbezhanov)

Full Changelog: v0.28.0...v0.28.1

v0.28.0

Added

• Added the pgtypes.Inet for inet type in PostgreSQL. (thanks @gstarikov)
• Added the pgtypes.Macaddr for macaddr and macaddr8 types in PostgreSQL.
• Added the pgtypes.LSN type for the pg_lsn type in PostgreSQL.
• Added the pgtypes.TxIDSnapshot type for the txid_snapshot type in PostgreSQL.
• Added the pgtypes.TSVector type for the tsvector type in PostgreSQL.
• Added AliasOf property to codegen type definitions to allow for defining types that have their own randomization logic.
• Added DependsOn property to codegen type definitions to allow for defining types that depend on other types. This ensures that necessary code for the dependent types is generated.
• Add xml type definition for custom randomization logic.
• Add the Cast() starter to all dialects to build CAST(expr AS type) expressions.
• Load index information for MySQL, PostgreSQL, and SQLite tables. (thanks @mbezhanov)

Changed

• Changed the parray package to pgtypes.
• Moved HStore to the pgtypes package.
• Simplified how random expressions are written for types by using standalone functions instead of a single generic function.
• The default DebugPrinter now prints args a bit more nicely by using thier Value() method if they implement the driver.Valuer interface.
• Only generate 2 random values when testing random expressions.

Removed

• Removed types.Stringer[T]. It makes assumptions for how the type should be scanned and is not reliable.

Fixed

• Do not add FROM clause to SELECT queries that are used as subqueries.
• Enum values are now checked for validity after scanning.

New Contributors

• @gstarikov made their first contribution in #234
• @mbezhanov made their first contribution in #236

Full Changelog: v0.27.1...v0.28.0

v0.27.1

Fixed

• Fixed bug in Count() queries not removing the offset from the original query. (thanks @daddz)

Full Changelog: v0.27.0...v0.27.1

v0.27.0

Added

• Add PreloadAs PreloadOption to override the join alias when preloading a relationship with a left join. (thanks @daddz)

• Add AliasedAs() method to tableColumns and tableWhere types to use a custom alias.

• Add AliasedAs() method to generated relationship join mods. This is avaible in two places:

  • one to change the alias of the table being queried

    models.SelectJoins.Jets.AliasedAs("j").InnerJoin.Pilots(ctx)

  • and the other to change the alias of the relationship.

    models.SelectJoins.Jets.InnerJoin.Pilots(ctx).AliasedAs("p")

• Add fm mods to all supported dialects (psql, mysql and sqlite). These are mods for functions and are used to modify the function call. For example:

  // import "github.com/stephenafamo/bob/dialect/psql/fm"
  psql.F( "count", "*",)(fm.Filter(psql.Quote("status").EQ(psql.S("done"))))

• Add MustCreate, MustCreateMany, CreateOrFail and CreateManyOrFail methods to generated factory Templates

Changed

• Change the function call point for generated relationship join mods. This reduces the amount of allocations and only does the work for the relationship being used.

  // Before
  models.SelectJoins(ctx).Jets.InnerJoin.Pilots
  // After
  models.SelectJoins.Jets.InnerJoin.Pilots(ctx)

• Changed the Count() function on Views to clone the query instead of changing the existing one. This makes queries reusable and the Count() function to behave as one would expect.

  // This now works as expected
  query := models.Jets.Query(ctx, db, /** list of various mods **/)
  count, err := query.Count()
  items, err := query.All()

• Changed how functions are modified. Instead of chained methods, the F() starter now returns a function which can be called with mods:

  // Before
  psql.F( "count", "*",).FilterWhere(psql.Quote("status").EQ(psql.S("done"))),
  // After
  // import "github.com/stephenafamo/bob/dialect/psql/fm"
  psql.F( "count", "*",)(fm.Filter(psql.Quote("status").EQ(psql.S("done")))),

  This makes it possible to support more queries.

• Use netip.Addr instead of netip.Prefix for Postgres cidr type.

• Use decimal.Decimal instead of string for Postgres money type.

• Use net.HardwareAddr for Postgres macaddr8 type, in addition to the macaddr type.

• Code generation now generates struct tags for the generated model Setters as well, if configured through the Tags configuration option. Previoulsy, only the model struct fields were tagged. (thanks @singhsays)

Removed

• Remove TableWhere function from the generated code. It was not used by the rest of the generated code and offered no clear benefit.
• Removed As starter. It takes an Expression and is not needed since the Expression has an As method which can be used directly.

Fixed

• Fix a bug with types.Stringer[T] where the wrong value was returned in the Value() method.

New Contributors

• @daddz made their first contribution in #220
• @singhsays made their first contribution in #225

Full Changelog: v0.26.1...v0.27.0

v0.26.1

Fixed

• Use netip.Prefix instead of netip.Addr for postgres inet column type. This makes it possible to contain a subnet. By @stephenafamo in #217
• Allow underscores in enum variable names. By @stephenafamo in #218
• Fix an issue with title casing enum values. By @stephenafamo in #219

Full Changelog: v0.26.0...v0.26.1