6734a9e4d6e2a8cfdd417a0f98e4ae8c4af2a2ff Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/cb2f8f0e072e5cf593005989fa308d5dc715ac00 cb2f8f0e072e5cf593005989fa308d5dc715ac00

2008-11-03T17:52:02-08:00

Bump version to 2.7.0 e6ea78859159800e97e4c8566abbe636754db956 Jeremy Evans code@jeremyevans.net 33599704330912f221cd0e6a59b3eccec373f359 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/6734a9e4d6e2a8cfdd417a0f98e4ae8c4af2a2ff 6734a9e4d6e2a8cfdd417a0f98e4ae8c4af2a2ff

2008-11-01T18:41:51-07:00

Slightly longer sleep in connection pool spec, prevents occassional spec failures 6edd98359e2880118aad27868c5d1e5f8bdf4083 Jeremy Evans code@jeremyevans.net 093264af72ac93ae6a261b7d333fecb453dd6a56 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/33599704330912f221cd0e6a59b3eccec373f359 33599704330912f221cd0e6a59b3eccec373f359

2008-11-01T18:41:05-07:00

2008-11-01T18:39:01-07:00

Make sure SQL::SQLArray is handled correctly when used as a hash value, so you get IN instead of = 20e2afd5ef43c3c8ae3b98351ddfe3f5fa857e65 Jeremy Evans code@jeremyevans.net 89afcdbf4e778b2a235a1196a51b900f65e59da0 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/093264af72ac93ae6a261b7d333fecb453dd6a56 093264af72ac93ae6a261b7d333fecb453dd6a56

2008-11-01T16:25:32-07:00

Add a couple of specs to bring coverage back to 100% 781be0f37fef54b65815509d669298ebe12fcdf3 Jeremy Evans code@jeremyevans.net 5f12bf31633c637b5c09e0840adaa8ea3a72713d Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/89afcdbf4e778b2a235a1196a51b900f65e59da0 89afcdbf4e778b2a235a1196a51b900f65e59da0

2008-11-01T16:08:47-07:00

Transform AssociationReflection from a single class to a class hierarchy This commit refactors association reflections from a single class to a parent class (still called AssociationReflection), with a subclass for each association type. The AssociationReflection instance methods previously had many checks for the association's type in order to perform the correct behavior. Type-specific behavior is one of the main benefits of using classes. This commit has some small breakage of backwards compatibility. The ASSOCIATION_TYPES constant moves from instead AssociationReflection to inside Associations, and becomes a hash with symbol keys and class values, instead of an array of symbols. The RECIPROCAL_ASSOCIATIONS constant has been eliminated. This commit does increase the amount of code, but it also makes the code simpler. In addition, it makes it much easier to add custom association classes that are still supported by associate. You just add the type to ASSOCIATION_TYPES, the key being the association name symbol, and the value being the custom association class. 661c8f14f2a93f22e78594c0dba7316da9964a8d Jeremy Evans code@jeremyevans.net 8e82e87637eef3b24c641ff5c8db1ebd967b57c4 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/5f12bf31633c637b5c09e0840adaa8ea3a72713d 5f12bf31633c637b5c09e0840adaa8ea3a72713d

2008-11-01T15:02:44-07:00

2008-11-01T15:01:52-07:00

Optimize Date object creation in PostgreSQL adapter This commit changes the PostgreSQL adapter to use Date.new instead of Date.parse when it encounters a date field. Date.new is 3-5 faster according to my benchmarking. Depending on the number of date fields you have in your query, this can dramatically speed up fetches. Note that even with this commit, date fields still dramatically slow fetches down, because the ruby Date class is slow to instantiate. To implement this, add a apply_connection_settings method to Postgres::Adapter, and have it run on initial connection as well as any time the connection is reset. You can turn off this optimization with Sequel::Postgres.use_iso_date_format = false, which may be necessary if you use a non-ISO date style and changing the date style to ISO causes problems. 618779d066bc5afd3f8975b2766fc43544b67f7f Jeremy Evans code@jeremyevans.net 8b6a6a240f2803222caa22ddfbc47f1c28308bb8 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/8e82e87637eef3b24c641ff5c8db1ebd967b57c4 8e82e87637eef3b24c641ff5c8db1ebd967b57c4

2008-10-31T21:46:50-07:00

Add :eager_grapher option to associations, which the user can use to override the default eager_graph code This commit makes some significant internal changes to the graph code. Instead of having a case statement in one of the methods called by eager_graph, it now unconditionally calls the :eager_grapher option for the association. Also, the :alias_association_type_map eager graph variable now holds only true or false instead of the association's type. This commit also removes all reliance on the reflection[:type] option, users can now define their own associations, which should work as long as they have the same API as AssociationReflection. There is no explicit support for them, nor did I do any testing to make sure that they are allowed, but this definitely removes a couple of hurdles. To remove the reliance on type, #reciprocal_array? and is anything standing in the way of custom association types, attempts will be made accomodate them. 4a23faede64dcd8ae026ea6d7b884c1f856172f1 Jeremy Evans code@jeremyevans.net 9916c9c815672b0ff304ffd7c27bf98f623f7245 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/8b6a6a240f2803222caa22ddfbc47f1c28308bb8 8b6a6a240f2803222caa22ddfbc47f1c28308bb8

2008-10-31T20:23:38-07:00

Associations are now inherited when a model class is subclassed This commit adds the @association_reflections instance variable to the list of instance variables to copy when subclassing. It also turns association_reflections from a private class method to a public class method. e20970129045c117ada1020fc80b998b0cd0bcb4 Jeremy Evans code@jeremyevans.net 92bec02708e47edc991272941fc1c9ef9396db71 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/9916c9c815672b0ff304ffd7c27bf98f623f7245 9916c9c815672b0ff304ffd7c27bf98f623f7245

2008-10-31T20:04:30-07:00

Instance methods added by associations are now added to an anonymous module the class includes, allowing you to override them and use super This commit renames the @column_accessors_module to @overridable_methods_module, since it is now used for holding association methods as well as column accessor methods. It also adds an overridable_methods_module private class method for ease of use. 8831f4c0d0d7bc668675623fd75f0113913e7916 Jeremy Evans code@jeremyevans.net ca098480443084296c9c693948ff171dacb14a08 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/92bec02708e47edc991272941fc1c9ef9396db71 92bec02708e47edc991272941fc1c9ef9396db71

2008-10-31T16:50:39-07:00

Add #add_graph_aliases (select_more for graphs), and allow use of arbitrary expressions when graphing Just like select_more adds columns to the already selected columns, add_graph_aliases adds columns to the already graphed columns. In addition, both set_graph_aliases and add_graph_aliases take an optional third argument for each value in the hash, specifying an arbitrary expression. This expression is used in place of the combination of the first and second arguments. For example: ds.set_graph_aliases!(:a=>[:b, :c], :d=>[:e, :f, 42]) # SELECT b.c AS a, 42 AS d FROM ... ds.first # => {:b=>{:c=>?}, :e=>{:f=>42}} 93dcccc8592c9d2617a90dd4bac5fdd0bc491489 Jeremy Evans code@jeremyevans.net a3f16f817498ed876dece7a0fc3e1e347a577e3b Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/ca098480443084296c9c693948ff171dacb14a08 ca098480443084296c9c693948ff171dacb14a08

2008-10-31T16:06:04-07:00

2008-10-31T15:56:14-07:00

Make Dataset#join_table take an option hash instead of a table_alias argument, add support for :implicit_qualifier option This commit fixes a long standing bug when eager loading via eager_graph. If you are eagerly loading multiple associations for the same model and you add any conditions with :graph_conditions or :graph_only_conditions, all associations for that model other than the first, would implicitly qualify the value conditions with the last association table alias instead of the table alias for the model. This is hard to explain, so here's a demonstration: Album.many_to_one :band # Tracks with the same name as the album Album.one_to_many :same_name_tracks, :class=>:Track, \ :graph_conditions=>{:name=>:name} Album.eager_graph(:band, :same_name_tracks).sql # => ... FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) LEFT OUTER JOIN tracks AS same_name_tracks ON \ ((same_name_tracks.album_id = albums.id) AND \ (same_name_tracks.name = band.name)) ^^^^ That's the mistake, as it should use albums.name instead of band.name. This commit fixes that, by adding an option to join_table that allows explicitly specifying the implicit qualifier for the values. join_table already had a table_alias argument added. In hindsight, that was a mistake. Change that argument to an option hash, keeping backwards compatibility. Add support for :implicit_qualifier option to graph as well, which just passes it to join table. Have eager_graph use the :implicit_qualifer option, and no longer qualify the keys manually in eager_graph. a24164668666b9a5b8bfa8aaff01ba47e4f798de Jeremy Evans code@jeremyevans.net 542a3dade8bcab994f4a5e8480bb53f8ec208544 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/a3f16f817498ed876dece7a0fc3e1e347a577e3b a3f16f817498ed876dece7a0fc3e1e347a577e3b

2008-10-31T13:29:59-07:00

Add :left_primary_key and :right_primary_key options to many_to_many associations This is for consistency with the :primary_key options recently added to one_to_many and many_to_one associations. fcf03fd745b6cfe8020471de45fd21ef111c3ae2 Jeremy Evans code@jeremyevans.net 8729419b0fdfb260775f505becdb905fd419d267 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/542a3dade8bcab994f4a5e8480bb53f8ec208544 542a3dade8bcab994f4a5e8480bb53f8ec208544

2008-10-31T11:43:16-07:00

More specs for :primary_key option, and fix bug in many_to_one eager loading This commit fixes a bug in many_to_one eager loading when the :primary_key option doesn't point to the associated table's primary key. It also refactors eager_load somewhat, and only runs after_load callbacks for all objects eagerly loaded if there are any after_load callbacks for the association, which should be a significant speed improvement. 3e22bfa7da979b31533e2ebbdb5ae03a300fa1bb Jeremy Evans code@jeremyevans.net d91d77e38fbed78471c938d1775c101e927bb97c Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/8729419b0fdfb260775f505becdb905fd419d267 8729419b0fdfb260775f505becdb905fd419d267

2008-10-31T10:29:05-07:00

Support :encoding option when using postgres adapter with postgres-pr 055d76a312f2fd9258cff2652e9ed61d7e17bb4a Jeremy Evans code@jeremyevans.net ef033d2e312b35e424b008a1aeffddfb89e96ef4 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/d91d77e38fbed78471c938d1775c101e927bb97c d91d77e38fbed78471c938d1775c101e927bb97c

2008-10-30T16:50:47-07:00

Add :primary_key option to one_to_many and many_to_one associations This commit allows you to choose which key to use as the primary key for one_to_many and many_to_one associations. Generally, for one_to_many associations, this is the primary key in the current table, and for many_to_one associations, it is the primary key in the associated table. However, there may be cases where you want to associate two models together, with a column in one model pointing to a non-primary key column in another model. This option allows for that, and it's also supported when eager loading via eager or eager_graph. This commit also adds an eager_loader_key method to AssociationReflection, removing some custom code from eager_load. This should make adding custom associations easier. e9e752996c91f197e3f4ca7490ae8f3668223041 Jeremy Evans code@jeremyevans.net 915ccc1acb6dbcde570912441e0512a20ef751eb Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/ef033d2e312b35e424b008a1aeffddfb89e96ef4 ef033d2e312b35e424b008a1aeffddfb89e96ef4

2008-10-30T15:37:49-07:00

Use a symbol instead of a proc for the :uniq option, should save memory 3b78133ae43f9538ff8353af6132c8792f83af22 Jeremy Evans code@jeremyevans.net 1cfb97eac6998e3d6ffd247eb8419ea073d51276 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/915ccc1acb6dbcde570912441e0512a20ef751eb 915ccc1acb6dbcde570912441e0512a20ef751eb

2008-10-29T16:46:03-07:00

2008-10-29T16:12:30-07:00

Make after_load association callbacks take effect when eager loading via eager Previously, they did not take affect when eager loading. They still do not take affect when eager loading via eager_graph, but now they take affect when eager loading via eager, since support was easy to add. They are supported outside the :eager_loader, so even if you define your own eager_loader, they still get run correctly. This is a slight breakage of backwards compatibility, but it's definitely the desired behavior in most circumstances. 2c03297392b51f7dc9f3d31354b34a0fcf6e894e Jeremy Evans code@jeremyevans.net bf1037c8a8cdbba335db29f5ef2dbb2fa91bb02e Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/1cfb97eac6998e3d6ffd247eb8419ea073d51276 1cfb97eac6998e3d6ffd247eb8419ea073d51276

2008-10-29T15:43:53-07:00

Add a :uniq association option to many_to_many associations The :uniq option adds a simple after_load callback that removes duplicate objects from the association. This doesn't really make sense for one_to_many associations, as all associated objects in a one_to_many association should be unique. cfca4fc953dade34f4fd7aaffccbd89672773b3b Jeremy Evans code@jeremyevans.net 7a25fb7082a5c831233cf5d35522fdd0b34bc5af Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/bf1037c8a8cdbba335db29f5ef2dbb2fa91bb02e bf1037c8a8cdbba335db29f5ef2dbb2fa91bb02e

2008-10-29T15:20:16-07:00

Support using any expression as the argument to Symbol#like Before :a.like(:b) would do "a LIKE 'b'" instead of "a LIKE b". This also didn't give the answer one would expect from code such as :a.like(:c[:b]). This breaks backwards compatibility, as before it would always treat the passed object as a string. However, I believe this is the more correct way to handle things. 0594611a70ea049f2f43fb3c1c412aeb403abb8f Jeremy Evans code@jeremyevans.net 8caefbcae9396595dd47e8d9507aebbc320a0525 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/7a25fb7082a5c831233cf5d35522fdd0b34bc5af 7a25fb7082a5c831233cf5d35522fdd0b34bc5af

2008-10-29T14:46:43-07:00

2008-10-29T14:45:40-07:00

Much better support for multiple schemas in PostgreSQL (Fixes #243) Sequel already had decent support for selecting data in tables outside the default schema, but it's support for schema manipulation and introspection for tables outside the default schema was lacking. This commit fixes that problem, though the approach could be taken further (by inspecting the schema search path and operating on all schemas in it). I have no plans to add that functionality, but I'll be happy to apply patches written by others who need it. This commit does the following: Makes the SQL generators schema-aware, though the default schema for every database except PostgreSQL is nil and cannot be changed. Explicitly uses the default schema when using PostgreSQL, which is set to public by default and can be changed with default_schema=. This breaks backwards compatibility for users who use a default schema other than public. If you use PostgreSQL and a schema other than public, use DB.default_schema=, and any time you want to access a table outside of that schema, make sure to qualify it with a schema name. Makes the primary key and sequence introspectors for PostgreSQL schema aware. The sequence introspectors now return a quoted, qualified sequence. This makes inserting into a table outside a schema in the schema path return the primary key value. Makes #table_exists? and #tables schema aware. #tables now accepts a block and yields a dataset if a block is given, instead of returning an array of symbols. #table_exists? uses this new feature. The @primary_keys and @primary_key_sequences instance variable hashes are keyed on "schema"."table" instead of on table. 65f87560a9441698aa72f8b3662d69de315f5ab3 Jeremy Evans code@jeremyevans.net 3b5e5ade5a7905c5fd1edd5346860fd252f9adba Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/8caefbcae9396595dd47e8d9507aebbc320a0525 8caefbcae9396595dd47e8d9507aebbc320a0525

2008-10-28T16:29:59-07:00

Update CHANGELOG for recent commit 31dcd1095fbf3b1edab8c805afbf20ca00d39ccc Jeremy Evans code@jeremyevans.net 8c2ffddbfc7d615fffa049d4ff47506343ab4335 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/3b5e5ade5a7905c5fd1edd5346860fd252f9adba 3b5e5ade5a7905c5fd1edd5346860fd252f9adba

2008-10-28T15:30:03-07:00

2008-10-28T15:23:29-07:00

Lazy load model instance options such as raise_on_save_failure, for performance reasons Before, 6 model instance options were loaded on initialize, which slowed things down, as often it wasn't necessary to load them. Now, don't load any instance option until it is necessary. Add Module#class_attr_overridable to implement this. It defines an instance method which gets it default value from the class method, but can be overridden using a standard attr_writer. This commit breaks backwards compatibility by removing the Model.lazy_load_schema setting. That setting was necessary when loading the schema was very slow and you were reloading code. It shouldn't be necessary now, as you can use DB.schema to get schema for all tables at once, and even if you reload the model class, you should be able to use the database's cached value (not to mention that parsing the schema should be a fairly fast operation now). This changes Model#initialize to not call a passed block if from_db is true. That should only be set by Model.load, which doesn't use a block. Also, Model#initialize now defaults to {} for the values instead of nil, and passing nil now causes an error (this is also a slight breakage of backwards compatibility). bed41da597a78f2001d584ac52cff12e454f8de1 Jeremy Evans code@jeremyevans.net 34fadfb7e18ef7107bc2bf8d523e903badba2103 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/8c2ffddbfc7d615fffa049d4ff47506343ab4335 8c2ffddbfc7d615fffa049d4ff47506343ab4335

2008-10-28T12:05:18-07:00

Make Model::Validiation::Errors more Rails-compatible Add a #count method that returns the number of error messages. Break backwards compatibility by making #on return nil instead of [] if there are no error messages for the given attribute. 11b28ab1ba6972463c4a41aba2d78a8d6c2f2572 Jeremy Evans code@jeremyevans.net 587fc3a7170005db8bdf1454d968c8f436d262c5 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/34fadfb7e18ef7107bc2bf8d523e903badba2103 34fadfb7e18ef7107bc2bf8d523e903badba2103

2008-10-28T11:52:42-07:00

Refactor model hooks for increased performance This change mainly stemmed from the fact that the call to after_initialize in Model.initialize caused about a 20% performance hit when fetching records, even if no after_initialize hook was defined. The main performance enhancing change in this commit is that hook instance methods are defined to be empty until a hook class method is called, which redefines the hook instance method of the given type to actually call the hooks. Refactor model hooks so they are inherited when the class is created, at which point future hooks added to the superclass are not seen in the subclass. This makes sure that the @hooks class instance variable is always available, except inside a block passed to Class.new (see the spec changes in this commit for a work around). It also simplifies Model.has_hooks?. This breaks backwards compatibility slightly, if you were adding hooks to a superclass after a subclass had been created and expecting the hooks to appear in the subclass. This commit removes the Model.hooks and Model.all_hooks private class methods. It adds a Model.hook_blocks public class method that yields all hook blocks for the given type of hook. run_hooks is now a private instance method instead of a private class method. 5ff9ab6bc8bcf7b7e5811479e3308a1c3bc8c2ad Jeremy Evans code@jeremyevans.net 64cb3a6da2d8568c510c5cb60c0e7233a470b6cc Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/587fc3a7170005db8bdf1454d968c8f436d262c5 587fc3a7170005db8bdf1454d968c8f436d262c5

2008-10-28T10:21:00-07:00

Major performance enhancement when fetching rows using PostgreSQL I did some profiling and found that fetching rows on PostgreSQL was a significant bottleneck. The previous code was decidely suboptimal, this new code should be significantly faster. Basically, the old code was doing a hash lookup and calls to fname and ftype for every column of every record, when those could be done in advance (since they are the same for every record). I've seen about a 3x improvement in speed, and that's on fetches of only 150 records, it should be greater on larger fetches. Profiling also showed that Postgres.string_to_bool was a bottleneck. Doing some research showed that postgresql always gives 't' for true, and 'f' for false. It shouldn't be called for NULL records, so the conversation can be reduced to "== 't'", which is simple enough it should not require a method, so I inlined it. ed94666558c6446c373de8221696d59fc728c1d2 Jeremy Evans code@jeremyevans.net f0bf091b842fb2dea17ddcd6da87ae39e5ffa805 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/64cb3a6da2d8568c510c5cb60c0e7233a470b6cc 64cb3a6da2d8568c510c5cb60c0e7233a470b6cc

2008-10-27T18:04:10-07:00

2008-10-27T11:18:06-07:00

Don't typecast serialized columns in models Assigning to a serialized column in a typecasting supported database was probably broken after typecasting support was added. Thankfully, the fix is easy. a36508e0d1dd3b457d7199167bd484a798e0f0c8 Jeremy Evans code@jeremyevans.net ffafaaa1c1f7061a94a951e92032c445b5f4eee6 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/f0bf091b842fb2dea17ddcd6da87ae39e5ffa805 f0bf091b842fb2dea17ddcd6da87ae39e5ffa805

2008-10-27T11:15:06-07:00

2008-10-27T11:14:53-07:00

Add Array#sql_array to handle ruby arrays of all two pairs as SQL arrays (Fixes #245) Previously, this wasn't possible, as ruby arrays of all two pairs were interpreted as conditions (sort of like an ordered hash). This allows you to do things like: DB[:foo].filter([:a,:b] => [[1,2],[3,4]].sql_array) # => SELECT * FROM foo WHERE ((a, b) IN ((1, 2), (3, 4))) 9a7c3b6f7928d731d97afc8f15a4ca9778bb121b Jeremy Evans code@jeremyevans.net 3d7f7852b91ebe5bf90d0543d4f5950f1de98d94 Fiodor Vereščiaka fiodor.veresciaka@gmail.com http://github.com/jeremyevans/sequel/commit/ffafaaa1c1f7061a94a951e92032c445b5f4eee6 ffafaaa1c1f7061a94a951e92032c445b5f4eee6

2008-10-27T10:11:22-07:00

2008-10-24T02:24:08-07:00

Postgres numeric returns either "numeric" or "numeric(x,y)" where x is precision and y is scale. So added support for for last. 30cba5cfd25a8d36f5164d269e8d72171996e1d9 Jeremy Evans code@jeremyevans.net bfd6210d05db52dba2ea6e3a7ae01115b0f41dd4 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/3d7f7852b91ebe5bf90d0543d4f5950f1de98d94 3d7f7852b91ebe5bf90d0543d4f5950f1de98d94

2008-10-23T14:29:33-07:00

Add a spec for Dataset#from handling :schema__table___alias symbols 7acde911fa86ea3413abeb81dd82faf5e9e44962 Jeremy Evans code@jeremyevans.net bde93ce91b49fe738088341ea1629be8013e1bc1 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/sequel/commit/bfd6210d05db52dba2ea6e3a7ae01115b0f41dd4 bfd6210d05db52dba2ea6e3a7ae01115b0f41dd4

2008-10-23T13:32:42-07:00

2008-10-23T13:29:48-07:00

Add plugin page to Sequel website Currently, only list sequel-notnaughty and sequel-timestamped as available plugins. Others will be added on request. a747261d5303c555013e75f77a7c01998bc23717 Jeremy Evans code@jeremyevans.net