Python util.text_type方法代码示例

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def test_no_convert_unicode(self):
        """test no utf-8 encoding occurs"""

        dialect = sqlite.dialect()
        for t in (
            String(),
            sqltypes.CHAR(),
            sqltypes.Unicode(),
            sqltypes.UnicodeText(),
            String(),
            sqltypes.CHAR(),
            sqltypes.Unicode(),
            sqltypes.UnicodeText(),
        ):
            bindproc = t.dialect_impl(dialect).bind_processor(dialect)
            assert not bindproc or isinstance(
                bindproc(util.u("some string")), util.text_type
            ) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def test_reflect_unicode_no_nvarchar(self):
        metadata = self.metadata
        Table("tnv", metadata, Column("data", sqltypes.Unicode(255)))
        metadata.create_all()
        m2 = MetaData(testing.db)
        t2 = Table("tnv", m2, autoload=True)
        assert isinstance(t2.c.data.type, sqltypes.VARCHAR)

        if testing.against("oracle+cx_oracle"):
            assert isinstance(
                t2.c.data.type.dialect_impl(testing.db.dialect),
                cx_oracle._OracleString,
            )

        data = u("m’a réveillé.")
        t2.insert().execute(data=data)
        res = t2.select().execute().first()["data"]
        eq_(res, data)
        assert isinstance(res, util.text_type) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def test_convert_unicode(self, connection):
        meta = self.metadata
        t1 = Table(
            "unitest_table",
            meta,
            Column("id", Integer, primary_key=True),
            Column("descr", mssql.MSText()),
        )
        meta.create_all(connection)
        connection.execute(
            ue("insert into unitest_table values ('abc \xc3\xa9 def')").encode(
                "UTF-8"
            )
        )
        r = connection.execute(t1.select()).first()
        assert isinstance(r[1], util.text_type), (
            "%s is %s instead of unicode, working on %s"
            % (r[1], type(r[1]), meta.bind)
        )
        eq_(r[1], util.ue("abc \xc3\xa9 def")) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def test_charset_collate_table(self):
        t = Table(
            "foo",
            self.metadata,
            Column("id", Integer),
            Column("data", UnicodeText),
            mysql_default_charset="utf8",
            mysql_collate="utf8_bin",
        )
        t.create()
        m2 = MetaData(testing.db)
        t2 = Table("foo", m2, autoload=True)
        eq_(t2.kwargs["mysql_collate"], "utf8_bin")
        eq_(t2.kwargs["mysql_default charset"], "utf8")

        # test [ticket:2906]
        # in order to test the condition here, need to use
        # MySQLdb 1.2.3 and also need to pass either use_unicode=1
        # or charset=utf8 to the URL.
        t.insert().execute(id=1, data=u("some text"))
        assert isinstance(
            testing.db.scalar(select([t.c.data])), util.text_type
        ) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def test_python_type(self):
        eq_(types.Integer().python_type, int)
        eq_(types.Numeric().python_type, decimal.Decimal)
        eq_(types.Numeric(asdecimal=False).python_type, float)
        eq_(types.LargeBinary().python_type, util.binary_type)
        eq_(types.Float().python_type, float)
        eq_(types.Interval().python_type, datetime.timedelta)
        eq_(types.Date().python_type, datetime.date)
        eq_(types.DateTime().python_type, datetime.datetime)
        eq_(types.String().python_type, str)
        eq_(types.Unicode().python_type, util.text_type)
        eq_(types.Enum("one", "two", "three").python_type, str)

        assert_raises(
            NotImplementedError, lambda: types.TypeEngine().python_type
        ) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def test_processing(self, connection):
        users = self.tables.users
        self._data_fixture()

        result = connection.execute(
            users.select().order_by(users.c.user_id)
        ).fetchall()
        for assertstr, assertint, assertint2, row in zip(
            [
                "BIND_INjackBIND_OUT",
                "BIND_INlalaBIND_OUT",
                "BIND_INfredBIND_OUT",
            ],
            [1200, 1500, 900],
            [1800, 2250, 1350],
            result,
        ):
            for col in list(row)[1:5]:
                eq_(col, assertstr)
            eq_(row[5], assertint)
            eq_(row[6], assertint2)
            for col in row[3], row[4]:
                assert isinstance(col, util.text_type) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def _bindparam_requires_quotes(self, value):
        """Return True if the given identifier requires quoting."""
        lc_value = value.lower()
        return (lc_value in self.reserved_words
                or value[0] in self.illegal_initial_characters
                or not self.legal_characters.match(util.text_type(value))
                ) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def __init__(self, *arg, **kw):
        OracleExecutionContext_cx_oracle.__init__(self, *arg, **kw)
        self.statement = util.text_type(self.statement) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def _execute_scalar(self, stmt):
        return super(OracleExecutionContext_cx_oracle_with_unicode, self).\
            _execute_scalar(util.text_type(stmt)) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def on_connect(self):
        if self.cx_oracle_ver < (5,):
            # no output type handlers before version 5
            return

        cx_Oracle = self.dbapi

        def output_type_handler(cursor, name, defaultType,
                                size, precision, scale):
            # convert all NUMBER with precision + positive scale to Decimal
            # this almost allows "native decimal" mode.
            if self.supports_native_decimal and \
                    defaultType == cx_Oracle.NUMBER and \
                    precision and scale > 0:
                return cursor.var(
                    cx_Oracle.STRING,
                    255,
                    outconverter=self._to_decimal,
                    arraysize=cursor.arraysize)
            # if NUMBER with zero precision and 0 or neg scale, this appears
            # to indicate "ambiguous".  Use a slower converter that will
            # make a decision based on each value received - the type
            # may change from row to row (!).   This kills
            # off "native decimal" mode, handlers still needed.
            elif self.supports_native_decimal and \
                    defaultType == cx_Oracle.NUMBER \
                    and not precision and scale <= 0:
                return cursor.var(
                    cx_Oracle.STRING,
                    255,
                    outconverter=self._detect_decimal,
                    arraysize=cursor.arraysize)
            # allow all strings to come back natively as Unicode
            elif self.coerce_to_unicode and \
                    defaultType in (cx_Oracle.STRING, cx_Oracle.FIXED_CHAR):
                return cursor.var(util.text_type, size, cursor.arraysize)

        def on_connect(conn):
            conn.outputtypehandler = output_type_handler

        return on_connect 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def assert_raises_message(except_cls, msg, callable_, *args, **kwargs):
    try:
        callable_(*args, **kwargs)
        assert False, "Callable did not raise an exception"
    except except_cls as e:
        assert re.search(
            msg, util.text_type(e), re.UNICODE), "%r !~ %s" % (msg, e)
        print(util.text_type(e).encode('utf-8')) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def assert_raises_message(except_cls, msg, callable_, *args, **kwargs):
    try:
        callable_(*args, **kwargs)
        assert False, "Callable did not raise an exception"
    except except_cls as e:
        assert re.search(msg, util.text_type(e), re.UNICODE), "%r !~ %s" % (
            msg,
            e,
        )
        print(util.text_type(e).encode("utf-8")) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def _execute_scalar(self, stmt, type_):
        return super(OracleExecutionContext_cx_oracle_with_unicode, self).\
            _execute_scalar(util.text_type(stmt), type_) 

# 需要导入模块: from sqlalchemy import util [as 别名]
# 或者: from sqlalchemy.util import text_type [as 别名]
def _engine_fixture(self):
        buf = util.StringIO()

        def dump(sql, *multiparams, **params):
            buf.write(util.text_type(sql.compile(dialect=engine.dialect)))

        engine = create_mock_engine("postgresql://", executor=dump)
        return engine, buf