Commits

Michael Trier committed 3b416c1

Fixed up misspelling of propagate throughout.

  • Participants
  • Parent commits 764ffec
  • Branches rel_0_4

Comments (0)

Files changed (13)

 =======
 0.4.9
 =====
+- general:
+    - global "propigate"->"propagate" change.
+    
 - orm
     - polymorphic_union() function respects the "key" of each 
       Column if they differ from the column's name.
       towards [ticket:610])
     
     - repaired single table inheritance such that you 
-      can single-table inherit from a joined-table inherting
+      can single-table inherit from a joined-table inheriting
       mapper without issue [ticket:1036].
       
     - Fixed "concatenate tuple" bug which could occur with
           whether or not it remains attached to its also-deleted
           parent.
 
-        - delete-orphan casacde is properly detected on
+        - delete-orphan cascade is properly detected on
           relations that are present on superclasses when using
           inheritance.
 
   - _Label class overrides compare_self to return its ultimate
     object. meaning, if you say someexpr.label('foo') == 5, it
     produces the correct "someexpr == 5".
-  - _Label propigates "_hide_froms()" so that scalar selects
+  - _Label propagates "_hide_froms()" so that scalar selects
     behave more properly with regards to FROM clause #574
   - fix to long name generation when using oid_column as an order by
     (oids used heavily in mapper queries)
   - many-to-many relationships check that the number of rows deleted
     from the association table by a delete operation matches the
     expected results
-  - session.get() and session.load() propigate **kwargs through to
+  - session.get() and session.load() propagate **kwargs through to
     query
   - fix to polymorphic query which allows the original
     polymorphic_union to be embedded into a correlated subquery
   - fix to select_by(<propname>=<object instance>) -style joins in
     conjunction with many-to-many relationships, bug introduced in
     r2556
-  - the "primary_key" argument to mapper() is propigated to the
+  - the "primary_key" argument to mapper() is propagated to the
     "polymorphic" mapper. primary key columns in this list get
     normalized to that of the mapper's local table.
   - restored logging of "lazy loading clause" under
       are to work around glitchy SQLite behavior that doesnt understand
       "foo.id" as equivalent to "id", are now only generated in the case
       that those named columns are selected from (part of [ticket:513])
-    - the label() method on ColumnElement will properly propigate the
+    - the label() method on ColumnElement will properly propagate the
       TypeEngine of the base element out to the label, including a label()
       created from a scalar=True select() statement.
     - MS-SQL better detects when a query is a subquery and knows not to
       for **kwargs compat
     - slight tweak to raw execute() change to also support tuples
       for positional parameters, not just lists [ticket:523]
-    - fix to case() construct to propigate the type of the first
+    - fix to case() construct to propagate the type of the first
       WHEN condition as the return type of the case statement
 - orm:
     - fixed critical issue when, after options(eagerload()) is used,
 
     - quoting wont occur for literal columns when they are "proxied" into
       the column collection for their selectable (is_literal flag is
-      propigated). literal columns are specified via
+      propagated). literal columns are specified via
       literal_column("somestring").
 
     - added "fold_equivalents" boolean argument to Join.select(), which
       occur on the "backref" side of the operation [ticket:249]
 
     - added "refresh-expire" cascade [ticket:492].  allows refresh() and
-      expire() calls to propigate along relationships.
+      expire() calls to propagate along relationships.
 
     - more fixes to polymorphic relations, involving proper lazy-clause
       generation on many-to-one relationships to polymorphic mappers
     - also fixed CLOB read/write on a separate changeset.
 
     - auto_setinputsizes defaults to True for Oracle, fixed cases where
-      it improperly propigated bad types.
+      it improperly propagated bad types.
 
 - mysql:
     - added a catchall **kwargs to MSString, to help reflection of
     - fixed named PrimaryKeyConstraint generation [ticket:466] courtesy
       andrija at gmail
     - fixed generation of CHECK constraints on columns [ticket:464]
-    - fixes to tometadata() operation to propigate Constraints at column and
+    - fixes to tometadata() operation to propagate Constraints at column and
       table level
 - oracle:
     - when returning "rowid" as the ORDER BY column or in use with ROW_NUMBER
       now patches an "options" method, in conjunction with a relationship
       named "options". (relationships take precedence over monkeypatched
       assign_mapper methods).
-    - extension() query option propigates to Mapper._instance() method so that
+    - extension() query option propagates to Mapper._instance() method so that
       all loading-related methods get called [ticket:454]
     - eager relation to an inheriting mapper wont fail if no rows returned for
       the relationship.
   - added an error message if you actually try to modify primary key values on
     an entity and then flush it [ticket:412]
 - extensions
-  - added "validate=False" argument to assign_mapper, if True will insure that
+  - added "validate=False" argument to assign_mapper, if True will ensure that
     only mapped attributes are named [ticket:426]
   - assign_mapper gets "options", "instances" functions added (i.e.
     MyClass.instances())
 - added label() function to Select class, when scalar=True is used
 to create a scalar subquery
 i.e. "select x, y, (select max(foo) from table) AS foomax from table"
-- added onupdate and ondelete keyword arguments to ForeignKey; propigate
-to underlying ForeignKeyConstraint if present.  (dont propigate in the
+- added onupdate and ondelete keyword arguments to ForeignKey; propagate
+to underlying ForeignKeyConstraint if present.  (dont propagate in the
 other direction, however)
 - fix to session.update() to preserve "dirty" status of incoming object
 - sending a selectable to an IN via the in_() function no longer creates
     - a wide refactoring to "attribute loader" and "options" architectures.
     ColumnProperty and PropertyLoader define their loading behaivor via switchable
     "strategies", and MapperOptions no longer use mapper/property copying
-    in order to function; they are instead propigated via QueryContext
+    in order to function; they are instead propagated via QueryContext
     and SelectionContext objects at query/instances time.
     All of the internal copying of mappers and properties that was used to handle
     inheritance as well as options() has been removed; the structure
 if it was not loaded already
 - [ticket:256] - pass URL query string arguments to connect() function
 - [ticket:257] - oracle boolean type
-- custom primary/secondary join conditions in a relation *will* be propigated
+- custom primary/secondary join conditions in a relation *will* be propagated
 to backrefs by default.  specifying a backref() will override this behavior.
-- better check for ambiguous join conditions in sql.Join; propigates to a
+- better check for ambiguous join conditions in sql.Join; propagates to a
 better error message in PropertyLoader (i.e. relation()/backref()) for when
 the join condition can't be reasonably determined.
 - sqlite creates ForeignKeyConstraint objects properly upon table
 propname the same as another, for the purposes of overriding props
 and allowing the original propname to be accessible in select_by().
 - fix to typing in clause construction which specifically helps
-type issues with polymorphic_union (CAST/ColumnClause propigates
+type issues with polymorphic_union (CAST/ColumnClause propagates
 its type to proxy columns)
 - mapper compilation work ongoing, someday it'll work....moved
 around the initialization of MapperProperty objects to be after
 - postgres will not place SERIAL keyword on a primary key column
 if it has a foreign key constraint
 - cursor() method on ConnectionFairy allows db-specific extension
-arguments to be propigated [ticket:221]
-- lazy load bind params properly propigate column type [ticket:225]
+arguments to be propagated [ticket:221]
+- lazy load bind params properly propagate column type [ticket:225]
 - new MySQL types: MSEnum, MSTinyText, MSMediumText, MSLongText, etc.
 more support for MS-specific length/precision params in numeric types
 patch courtesy Mike Bernson
 [ticket:200]
 - small tweak to cascade_mappers, not very strongly supported
 function at the moment
-- some fixes to between(), column.between() to propigate typing
+- some fixes to between(), column.between() to propagate typing
 information better [ticket:202]
 - if an object fails to be constructed, is not added to the
 session [ticket:203]
 - more fixes to threadlocal connection nesting patterns
 
 0.2.1
-- "pool" argument to create_engine() properly propigates
+- "pool" argument to create_engine() properly propagates
 - fixes to URL, raises exception if not parsed, does not pass blank
 fields along to the DB connect string (a string such as
 user:host@/db was breaking on postgres)
 "threadlocal" mod if used
 - mods now called in via "import <modname>".  extensions favored over
 mods as mods are globally-monkeypatching
-- fix to add_property so that it propigates properties to inheriting
+- fix to add_property so that it propagates properties to inheriting
 mappers [ticket:154]
 - backrefs create themselves against primary mapper of its originating
 property, priamry/secondary join arguments can be specified to override.

lib/sqlalchemy/orm/mapper.py

             self.extension.append(ext)
 
     def __compile_inheritance(self):
-        """Configure settings related to inherting and/or inherited mappers being present."""
+        """Configure settings related to inheriting and/or inherited mappers being present."""
 
         if self.inherits:
             if isinstance(self.inherits, type):

lib/sqlalchemy/orm/properties.py

         self.order_by = order_by
         self.attributeext=attributeext
         if isinstance(backref, str):
-            # propigate explicitly sent primary/secondary join conditions to the BackRef object if
+            # propagate explicitly sent primary/secondary join conditions to the BackRef object if
             # just a string was sent
             if secondary is not None:
                 # reverse primary/secondary in case of a many-to-many

lib/sqlalchemy/sql/compiler.py

 
         correlate_froms = util.Set(itertools.chain(*([froms] + [f._get_from_objects() for f in froms])))
 
-        # TODO: might want to propigate existing froms for select(select(select))
+        # TODO: might want to propagate existing froms for select(select(select))
         # where innermost select should correlate to outermost
 #        if existingfroms:
 #            correlate_froms = correlate_froms.union(existingfroms)

lib/sqlalchemy/sql/expression.py

         return _BindParamClause(self.name, obj, type_=self.type, unique=True)
 
     def _make_proxy(self, selectable, name = None):
-        # propigate the "is_literal" flag only if we are keeping our name,
+        # propagate the "is_literal" flag only if we are keeping our name,
         # otherwise its considered to be a label
         is_literal = self.is_literal and (name is None or name == self.name)
         c = _ColumnClause(name or self.name, selectable=selectable, _is_oid=self._is_oid, type_=self.type, is_literal=is_literal)

test/engine/parseconnect.py

             assert str(u) == text
 
 class CreateEngineTest(TestBase):
-    """test that create_engine arguments of different types get propigated properly"""
+    """test that create_engine arguments of different types get propagated properly"""
     def test_connect_query(self):
         dbapi = MockDBAPI(foober='12', lala='18', fooz='somevalue')
 

test/orm/eager_relations.py

     test_limit_2 = testing.fails_on('maxdb')(test_limit_2)
 
     def test_limit_3(self):
-        """test that the ORDER BY is propigated from the inner select to the outer select, when using the
+        """test that the ORDER BY is propagated from the inner select to the outer select, when using the
         'wrapped' select statement resulting from the combination of eager loading and limit/offset clauses."""
 
         mapper(Item, items)

test/orm/inheritance/polymorph2.py

             Column('t2data', String(30)))
 
     def test_custompk(self):
-        """test that the primary_key attribute is propigated to the polymorphic mapper"""
+        """test that the primary_key attribute is propagated to the polymorphic mapper"""
 
         class T1(object):pass
         class T2(T1):pass

test/orm/relationships.py

 
     This is essentially an extension of the "dependency.py" topological sort
     test.  In this test, a table is dependent on two other tables that are
-    otherwise unrelated to each other.  The dependency sort must insure that
+    otherwise unrelated to each other.  The dependency sort must ensure that
     this childmost table is below both parent tables in the outcome (a bug
     existed where this was not always the case).
 

test/orm/unitofwork.py

         self.assert_(u.user_id == userid and a2.address_id == addressid)
 
     def test_onetomany_2(self):
-        """digs deeper into modifying the child items of an object to insure the correct
+        """digs deeper into modifying the child items of an object to ensure the correct
         updates take place"""
         m = mapper(User, users, properties = dict(
             addresses = relation(mapper(Address, addresses), lazy = True)

test/perf/massload.py

             l = query.filter(items.c.item_id.between(x*100 - 100 + 1, x*100)).all()
             assert len(l) == 100
             print "loaded ", len(l), " items "
-            # modifying each object will insure that the objects get placed in the "dirty" list
+            # modifying each object will ensure that the objects get placed in the "dirty" list
             # and will hang around until expunged
             #for a in l:
             #    a.value = 'changed...'

test/sql/query.py

     test_select_limit_offset = testing.unsupported('mssql')(test_select_limit_offset)
 
     def test_scalar_select(self):
-        """test that scalar subqueries with labels get their type propigated to the result set."""
+        """test that scalar subqueries with labels get their type propagated to the result set."""
         # mysql and/or mysqldb has a bug here, type isn't propagated for scalar
         # subquery.
         datetable = Table('datetable', metadata,

test/sql/testtypes.py

 
     def testmsnvarchar(self):
         dialect = mssql.MSSQLDialect()
-        # run the test twice to insure the caching step works too
+        # run the test twice to ensure the caching step works too
         for x in range(0, 1):
             col = Column('', Unicode(length=10))
             dialect_type = col.type.dialect_impl(dialect)