typoes in lib/sqlalchemy/dialects

7 files changed, 21 insertions, 21 deletions

diff --git a/lib/sqlalchemy/dialects/firebird/base.py b/lib/sqlalchemy/dialects/firebird/base.py
index 031c68919..5ef30b36d 100644
--- a/lib/sqlalchemy/dialects/firebird/base.py
+++ b/lib/sqlalchemy/dialects/firebird/base.py
@@ -198,7 +198,7 @@ class FBTypeCompiler(compiler.GenericTypeCompiler):
 
 
 class FBCompiler(sql.compiler.SQLCompiler):
-    """Firebird specific idiosincrasies"""
+    """Firebird specific idiosyncrasies"""
 
     def visit_mod(self, binary, **kw):
         # Firebird lacks a builtin modulo operator, but there is
@@ -293,7 +293,7 @@ class FBCompiler(sql.compiler.SQLCompiler):
 
 
 class FBDDLCompiler(sql.compiler.DDLCompiler):
-    """Firebird syntactic idiosincrasies"""
+    """Firebird syntactic idiosyncrasies"""
 
     def visit_create_sequence(self, create):
         """Generate a ``CREATE GENERATOR`` statement for the sequence."""
diff --git a/lib/sqlalchemy/dialects/mssql/base.py b/lib/sqlalchemy/dialects/mssql/base.py
index 103b0a3e9..e58721586 100644
--- a/lib/sqlalchemy/dialects/mssql/base.py
+++ b/lib/sqlalchemy/dialects/mssql/base.py
@@ -107,10 +107,10 @@ Compatibility Levels
 --------------------
 MSSQL supports the notion of setting compatibility levels at the
 database level. This allows, for instance, to run a database that
-is compatibile with SQL2000 while running on a SQL2005 database
+is compatible with SQL2000 while running on a SQL2005 database
 server. ``server_version_info`` will always return the database
 server version information (in this case SQL2005) and not the
-compatibiility level information. Because of this, if running under
+compatibility level information. Because of this, if running under
 a backwards compatibility mode SQAlchemy may attempt to use T-SQL
 statements that are unable to be parsed by the database server.
 
diff --git a/lib/sqlalchemy/dialects/mssql/mxodbc.py b/lib/sqlalchemy/dialects/mssql/mxodbc.py
index 765998697..94f0a2cbb 100644
--- a/lib/sqlalchemy/dialects/mssql/mxodbc.py
+++ b/lib/sqlalchemy/dialects/mssql/mxodbc.py
@@ -47,7 +47,7 @@ This behavior can be controlled via
 :meth:`~sqlalchemy.sql.expression.Executable.execution_options` using the
 ``native_odbc_execute`` flag with a value of ``True`` or ``False``, where a
 value of ``True`` will unconditionally use native bind parameters and a value
-of ``False`` will uncondtionally use string-escaped parameters.
+of ``False`` will unconditionally use string-escaped parameters.
 
 """
 
diff --git a/lib/sqlalchemy/dialects/postgresql/base.py b/lib/sqlalchemy/dialects/postgresql/base.py
index c4c2bbdb4..e87c0426e 100644
--- a/lib/sqlalchemy/dialects/postgresql/base.py
+++ b/lib/sqlalchemy/dialects/postgresql/base.py
@@ -1040,7 +1040,7 @@ class PGDialect(default.DefaultDialect):
         if is_prepared:
             if recover:
                 #FIXME: ugly hack to get out of transaction 
-                # context when commiting recoverable transactions
+                # context when committing recoverable transactions
                 # Must find out a way how to make the dbapi not 
                 # open a transaction.
                 connection.execute("ROLLBACK")
@@ -1625,8 +1625,8 @@ class PGDialect(default.DefaultDialect):
         for enum in c.fetchall():
             if enum['visible']:
                 # 'visible' just means whether or not the enum is in a
-                # schema that's on the search path -- or not overriden by
-                # a schema with higher presedence. If it's not visible,
+                # schema that's on the search path -- or not overridden by
+                # a schema with higher precedence. If it's not visible,
                 # it will be prefixed with the schema-name when it's used.
                 name = enum['name']
             else:
@@ -1665,8 +1665,8 @@ class PGDialect(default.DefaultDialect):
             attype = re.search('([^\(]+)', domain['attype']).group(1)
             if domain['visible']:
                 # 'visible' just means whether or not the domain is in a
-                # schema that's on the search path -- or not overriden by
-                # a schema with higher presedence. If it's not visible,
+                # schema that's on the search path -- or not overridden by
+                # a schema with higher precedence. If it's not visible,
                 # it will be prefixed with the schema-name when it's used.
                 name = domain['name']
             else:
diff --git a/lib/sqlalchemy/dialects/postgresql/pypostgresql.py b/lib/sqlalchemy/dialects/postgresql/pypostgresql.py
index e902c684e..14ede40a5 100644
--- a/lib/sqlalchemy/dialects/postgresql/pypostgresql.py
+++ b/lib/sqlalchemy/dialects/postgresql/pypostgresql.py
@@ -40,7 +40,7 @@ class PGDialect_pypostgresql(PGDialect):
     default_paramstyle = 'pyformat'
 
     # requires trunk version to support sane rowcounts
-    # TODO: use dbapi version information to set this flag appropariately
+    # TODO: use dbapi version information to set this flag appropriately
     supports_sane_rowcount = True
     supports_sane_multi_rowcount = False
 
diff --git a/lib/sqlalchemy/dialects/sqlite/base.py b/lib/sqlalchemy/dialects/sqlite/base.py
index 10a0d882b..b9cd783be 100644
--- a/lib/sqlalchemy/dialects/sqlite/base.py
+++ b/lib/sqlalchemy/dialects/sqlite/base.py
@@ -103,13 +103,13 @@ class DATETIME(_DateTimeMixin, sqltypes.DateTime):
                 regexp=re.compile("(\d+)/(\d+)/(\d+) (\d+)-(\d+)-(\d+)(?:-(\d+))?")
             )
     
-    :param storage_format: format string which will be appled to the 
+    :param storage_format: format string which will be applied to the 
      tuple ``(value.year, value.month, value.day, value.hour,
      value.minute, value.second, value.microsecond)``, given a
      Python datetime.datetime() object.
     
     :param regexp: regular expression which will be applied to 
-     incoming result rows. The resulting match object is appled to
+     incoming result rows. The resulting match object is applied to
      the Python datetime() constructor via ``*map(int,
      match_obj.groups(0))``.
     """
@@ -164,12 +164,12 @@ class DATE(_DateTimeMixin, sqltypes.Date):
                 regexp=re.compile("(\d+)/(\d+)/(\d+)")
             )
     
-    :param storage_format: format string which will be appled to the 
+    :param storage_format: format string which will be applied to the 
      tuple ``(value.year, value.month, value.day)``,
      given a Python datetime.date() object.
     
     :param regexp: regular expression which will be applied to 
-     incoming result rows. The resulting match object is appled to
+     incoming result rows. The resulting match object is applied to
      the Python date() constructor via ``*map(int,
      match_obj.groups(0))``.
      
@@ -221,12 +221,12 @@ class TIME(_DateTimeMixin, sqltypes.Time):
                 regexp=re.compile("(\d+)-(\d+)-(\d+)-(?:-(\d+))?")
             )
     
-    :param storage_format: format string which will be appled 
+    :param storage_format: format string which will be applied 
      to the tuple ``(value.hour, value.minute, value.second,
      value.microsecond)``, given a Python datetime.time() object.
     
     :param regexp: regular expression which will be applied to 
-     incoming result rows. The resulting match object is appled to
+     incoming result rows. The resulting match object is applied to
      the Python time() constructor via ``*map(int,
      match_obj.groups(0))``.
 
diff --git a/lib/sqlalchemy/dialects/sybase/pysybase.py b/lib/sqlalchemy/dialects/sybase/pysybase.py
index e12cf07dd..dd7b27251 100644
--- a/lib/sqlalchemy/dialects/sybase/pysybase.py
+++ b/lib/sqlalchemy/dialects/sybase/pysybase.py
@@ -82,10 +82,10 @@ class SybaseDialect_pysybase(SybaseDialect):
             cursor.execute(statement, param)
 
     def _get_server_version_info(self, connection):
-       vers = connection.scalar("select @@version_number")
-       # i.e. 15500, 15000, 12500 == (15, 5, 0, 0), (15, 0, 0, 0), 
-       # (12, 5, 0, 0)
-       return (vers / 1000, vers % 1000 / 100, vers % 100 / 10, vers % 10)
+        vers = connection.scalar("select @@version_number")
+        # i.e. 15500, 15000, 12500 == (15, 5, 0, 0), (15, 0, 0, 0), 
+        # (12, 5, 0, 0)
+        return (vers / 1000, vers % 1000 / 100, vers % 100 / 10, vers % 10)
 
     def is_disconnect(self, e, connection, cursor):
         if isinstance(e, (self.dbapi.OperationalError,