diana avatar diana committed 053f669

typoes in lib/sqlalchemy/dialects

Comments (0)

Files changed (7)

lib/sqlalchemy/dialects/firebird/base.py

 
 
 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
 
 
 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."""

lib/sqlalchemy/dialects/mssql/base.py

 --------------------
 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.
 

lib/sqlalchemy/dialects/mssql/mxodbc.py

 :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.
 
 """
 

lib/sqlalchemy/dialects/postgresql/base.py

         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")
         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:
             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:

lib/sqlalchemy/dialects/postgresql/pypostgresql.py

     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
 

lib/sqlalchemy/dialects/sqlite/base.py

                 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))``.
     """
                 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))``.
      
                 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))``.
 

lib/sqlalchemy/dialects/sybase/pysybase.py

             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,
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.