示例#1
0
 def test_raw_roundtrip(self):
     metadata = self.metadata
     raw_table = Table('raw', metadata,
                       Column('id', Integer, primary_key=True),
                       Column('data', oracle.RAW(35)))
     metadata.create_all()
     testing.db.execute(raw_table.insert(), id=1, data=b("ABCDEF"))
     eq_(
         testing.db.execute(raw_table.select()).first(),
         (1, b("ABCDEF"))
     )
示例#2
0
 def test_nonunicode_default(self):
     default = b('foo')
     assert_raises_message(
         sa.exc.SAWarning,
         "Unicode column received non-unicode default value.",
         Column,
         Unicode(32),
         default=default
     )
示例#3
0
 def test_nonunicode_default(self):
     default = b('foo')
     assert_raises_message(
         sa.exc.SAWarning,
         "Unicode column 'foobar' has non-unicode "
         "default value b?'foo' specified.",
         Column,
         "foobar", Unicode(32),
         default=default
     )
示例#4
0
    def test_unicode_warnings_dialectlevel(self):

        unicodedata = self.data

        with testing.expect_deprecated(
            "The create_engine.convert_unicode parameter and "
            "corresponding dialect-level"
        ):
            dialect = default.DefaultDialect(convert_unicode=True)
        dialect.supports_unicode_binds = False

        s = String()
        uni = s.dialect_impl(dialect).bind_processor(dialect)

        uni(util.b("x"))
        assert isinstance(uni(unicodedata), util.binary_type)

        eq_(uni(unicodedata), unicodedata.encode("utf-8"))
示例#5
0
    def insert_data(cls):
        cls.data = data = [
            dict(
                id=i, data='this is text %d' % i,
                bindata=b('this is binary %d' % i)
            ) for i in range(1, 20)
        ]

        testing.db.execute(cls.tables.z_test.insert(), data)

        binary_table = cls.tables.binary_table
        fname = os.path.join(
            os.path.dirname(__file__), "..", "..",
            'binary_data_one.dat')
        with open(fname, "rb") as file_:
            cls.stream = stream = file_.read(12000)

        for i in range(1, 11):
            binary_table.insert().execute(id=i, data=stream)
示例#6
0
 def test_character_binary(self):
     self._test_round_trip(mssql.MSVarBinary(800), b("some normal data"))
示例#7
0
 def test_lobs_with_convert_raw(self):
     row = testing.db.execute("select data, bindata from z_test").first()
     eq_(row["data"], "this is text 1")
     eq_(row["bindata"], b("this is binary 1"))
示例#8
0
 def test_lobs_with_convert_raw(self):
     row = testing.db.execute("select data, bindata from z_test").first()
     eq_(row['data'], 'this is text 1')
     eq_(row['bindata'], b('this is binary 1'))
示例#9
0
 def test_lobs_without_convert(self):
     engine = testing_engine(options=dict(auto_convert_lobs=False))
     t = self.tables.z_test
     row = engine.execute(t.select().where(t.c.id == 1)).first()
     eq_(row['data'].read(), 'this is text 1')
     eq_(row['bindata'].read(), b('this is binary 1'))
示例#10
0
 def test_lobs_with_convert(self):
     t = self.tables.z_test
     row = testing.db.execute(t.select().where(t.c.id == 1)).first()
     eq_(row['data'], 'this is text 1')
     eq_(row['bindata'], b('this is binary 1'))
示例#11
0
 def test_lobs_without_convert(self):
     engine = testing_engine(options=dict(auto_convert_lobs=False))
     t = self.tables.z_test
     row = engine.execute(t.select().where(t.c.id == 1)).first()
     eq_(row['data'].read(), 'this is text 1')
     eq_(row['bindata'].read(), b('this is binary 1'))
示例#12
0
 def test_lobs_with_convert_raw(self, connection):
     row = exec_sql(connection, "select data, bindata from z_test").first()
     eq_(row["data"], "this is text 1")
     eq_(row["bindata"], b("this is binary 1"))
示例#13
0
 def test_character_binary(self):
     self._test_round_trip(mssql.MSVarBinary(800), b("some normal data"))
示例#14
0
 def test_lobs_with_convert_raw(self):
     row = testing.db.execute("select data, bindata from z_test").first()
     eq_(row["data"], "this is text 1")
     eq_(row["bindata"], b("this is binary 1"))
示例#15
0
 def test_bytes(self):
     module = __import__('pymssql')
     input = b('\x80\x03]q\x00X\x03\x00\x00\x00oneq\x01a.')
     expected_result = input
     result = module.Binary(input)
     eq_(result, expected_result)
示例#16
0
 def test_lobs_with_convert_raw(self):
     row = testing.db.execute("select data, bindata from z_test").first()
     eq_(row['data'], 'this is text 1')
     eq_(row['bindata'], b('this is binary 1'))
示例#17
0
 def test_lobs_with_convert(self, connection):
     t = self.tables.z_test
     row = connection.execute(t.select().where(t.c.id == 1)).first()
     eq_(row["data"], "this is text 1")
     eq_(row["bindata"], b("this is binary 1"))
示例#18
0
 def test_lobs_with_convert(self):
     t = self.tables.z_test
     row = testing.db.execute(t.select().where(t.c.id == 1)).first()
     eq_(row['data'], 'this is text 1')
     eq_(row['bindata'], b('this is binary 1'))
示例#19
0
 def test_lobs_with_convert(self):
     t = self.tables.z_test
     row = testing.db.execute(t.select().where(t.c.id == 1)).first()
     eq_(row["data"], "this is text 1")
     eq_(row["bindata"], b("this is binary 1"))
示例#20
0
 def test_bytes(self):
     module = __import__('pymssql')
     input = b('\x80\x03]q\x00X\x03\x00\x00\x00oneq\x01a.')
     expected_result = input
     result = module.Binary(input)
     eq_(result, expected_result)
示例#21
0
class BinaryTest(fixtures.TestBase):
    __only_on__ = "mssql"
    __requires__ = ("non_broken_binary", )
    __backend__ = True

    @testing.combinations(
        (
            mssql.MSVarBinary(800),
            b("some normal data"),
            None,
            True,
            None,
            False,
        ),
        (
            mssql.VARBINARY("max"),
            "binary_data_one.dat",
            None,
            False,
            None,
            False,
        ),
        (
            mssql.VARBINARY("max"),
            "binary_data_one.dat",
            None,
            True,
            None,
            False,
        ),
        (
            sqltypes.LargeBinary,
            "binary_data_one.dat",
            None,
            False,
            None,
            False,
        ),
        (sqltypes.LargeBinary, "binary_data_one.dat", None, True, None, False),
        (mssql.MSImage, "binary_data_one.dat", None, True, None, False),
        (PickleType, pickleable.Foo("im foo 1"), None, True, None, False),
        (
            MyPickleType,
            pickleable.Foo("im foo 1"),
            pickleable.Foo("im foo 1", stuff="BINDim stuffRESULT"),
            True,
            None,
            False,
        ),
        (types.BINARY(100), "binary_data_one.dat", None, True, 100, False),
        (types.VARBINARY(100), "binary_data_one.dat", None, True, 100, False),
        (mssql.VARBINARY(100), "binary_data_one.dat", None, True, 100, False),
        (types.BINARY(100), "binary_data_two.dat", None, True, 99, True),
        (types.VARBINARY(100), "binary_data_two.dat", None, True, 99, False),
        (mssql.VARBINARY(100), "binary_data_two.dat", None, True, 99, False),
        argnames="type_, data, expected, deprecate_large_types, "
        "slice_, zeropad",
    )
    def test_round_trip(
        self,
        metadata,
        type_,
        data,
        expected,
        deprecate_large_types,
        slice_,
        zeropad,
    ):
        if (testing.db.dialect.deprecate_large_types
                is not deprecate_large_types):
            engine = engines.testing_engine(
                options={"deprecate_large_types": deprecate_large_types})
        else:
            engine = testing.db

        binary_table = Table(
            "binary_table",
            metadata,
            Column("id", Integer, primary_key=True),
            Column("data", type_),
        )
        binary_table.create(engine)

        if isinstance(data, str) and (data == "binary_data_one.dat"
                                      or data == "binary_data_two.dat"):
            data = self._load_stream(data)

        if slice_ is not None:
            data = data[0:slice_]

        if expected is None:
            if zeropad:
                expected = data[0:slice_] + b"\x00"
            else:
                expected = data

        with engine.begin() as conn:
            conn.execute(binary_table.insert(), dict(data=data))

            eq_(conn.scalar(select(binary_table.c.data)), expected)

            eq_(
                conn.scalar(
                    text("select data from binary_table").columns(
                        binary_table.c.data)),
                expected,
            )

            conn.execute(binary_table.delete())

            conn.execute(binary_table.insert(), dict(data=None))
            eq_(conn.scalar(select(binary_table.c.data)), None)

            eq_(
                conn.scalar(
                    text("select data from binary_table").columns(
                        binary_table.c.data)),
                None,
            )

    def _load_stream(self, name, len_=3000):
        fp = open(os.path.join(os.path.dirname(__file__), "..", "..", name),
                  "rb")
        stream = fp.read(len_)
        fp.close()
        return stream