public async Task CreateTableWithForeignKey(OrmConnectionFactory factory)
        {
            using (var c = factory.OpenConnection())
            {
                Assert.False(await c.TableExistsAsync <OnePk>());
                Assert.False(await c.TableExistsAsync <OneFk>());

                await c.CreateTableAsync <OnePk>(true);

                await c.CreateTableAsync <OneFk>(true);

                Assert.True(await c.TableExistsAsync <OnePk>());
                Assert.True(await c.TableExistsAsync <OneFk>());
                Assert.Equal(1, await c.InsertAsync(new OnePk {
                    Pk = "1"
                }));
                Assert.Equal(1, await c.InsertAsync(new OneFk {
                    Fk = "1"
                }));

                await Assert.ThrowsAsync <OrmException>(async() => await c.InsertAsync(new OneFk {
                    Fk = "2"
                }));
            }
        }
Example #2
0
        protected OrmConnection OpenDbConnection()
        {
            if (_conn?.DbConnection == null)
            {
                _conn = _connectionFactory.OpenConnection();
            }

            return(_conn);
        }
        public async Task CreateTableWithoutPrimaryKeys(OrmConnectionFactory factory)
        {
            using (var c = factory.OpenConnection())
            {
                Assert.False(await c.TableExistsAsync <NoPk>());
                await c.CreateTableAsync <NoPk>(true);

                Assert.Equal(1, await c.InsertAsync(new NoPk()));
                Assert.True(await c.TableExistsAsync <NoPk>());
            }
        }
        public void GetTableColumnInfo(OrmConnectionFactory factory)
        {
            using (var conn = factory.OpenConnection())
            {
                conn.CreateTable <WithAttributes>(true);

                var t = conn.GetTableColumnsInformation("WithAttributes").ToList();

                Assert.NotNull(t);
                Assert.NotEmpty(t);
                Assert.Equal(8, t.Count);
                Assert.True(t[0].PrimaryKey);
            }
        }
        public async Task CreateTableWithAliases(OrmConnectionFactory factory)
        {
            using (var c = factory.OpenConnection())
            {
                await c.CreateTableAsync <WithAlias>(true);

                Assert.True(await c.TableExistsAsync <WithAlias>());

                c.Select <WithAlias>(x =>
                {
                    Assert.Equal(c.DialectProvider.GetQuotedTableName("withaliasrenamed"), x.Statement.TableName);
                    Assert.Equal(c.DialectProvider.GetQuotedColumnName("columnAlias") + " AS Column1", x.Statement.Columns[0]);
                });
            }
        }
        public async Task CreateTableWithAliasAndSchema(OrmConnectionFactory factory)
        {
            using (var c = factory.OpenConnection())
            {
                await c.CreateSchemaIfNotExistsAsync("TS");

                await c.CreateTableAsync <WithSchemaAndAlias>(true);

                Assert.True(await c.TableExistsAsync <WithSchemaAndAlias>());

                Assert.NotEmpty(c.GetTablesInformation("TS", false)
                                .Select(x => x.SchemaName == "TS" && x.Name == "withaliasansschema"));

                c.Select <WithSchemaAndAlias>(x =>
                {
                    Assert.Equal(c.DialectProvider.GetQuotedTableName("withaliasansschema", "TS"), x.Statement.TableName);
                    Assert.Equal(c.DialectProvider.GetQuotedColumnName("columnAlias") + " AS Column1", x.Statement.Columns[0]);
                });
            }
        }