internal FromManyChainer(Chainer prev,
TableArgument firstTable,
TableArgument secondTable,
TableArgument[] otherTables)
: base(prev)
{
CheckNullAndThrow(Arg(() => firstTable, firstTable));
CheckNullAndThrow(Arg(() => secondTable, secondTable));
CheckNullAndThrow(Arg(() => otherTables, otherTables));
if (otherTables.Where(table => table == null).Any())
{
Throw(QueryTalkExceptionType.ArgumentNull, "table = null");
}
Build = (buildContext, buildArgs) =>
{
StringBuilder sql = Text.GenerateSql(200);
ProcessTable(buildContext, buildArgs, firstTable, sql);
ProcessTable(buildContext, buildArgs, secondTable, sql);
Array.ForEach(otherTables, table =>
{
ProcessTable(buildContext, buildArgs, table, sql);
});
TryThrow(buildContext);
return(sql.ToString());
};
}
private void Initialize(DT dt, TableArgument sysObject)
{
var root = GetRoot();
chainMethod = Text.Method.Declare;
CheckAndThrow();
CheckNullAndThrow(Arg(() => sysObject, sysObject));
TryThrow(sysObject.Exception);
var param = new Variable(0, _variableName, dt, sysObject, IdentifierType.SqlVariable);
root.TryAddVariableOrThrow(param, chainMethod, false);
Build = (buildContext, buildArgs) =>
{
var sql = Text.GenerateSql(30)
.NewLine(Text.Declare).S()
.Append(_variableName).S()
.Append(Text.As).S()
.Append(sysObject.Build(buildContext, buildArgs))
.Terminate();
TryThrow(buildContext);
return(sql.ToString());
};
}
internal string BaseBuildMethod(BuildContext buildContext, BuildArgs buildArgs)
{
string tableSql = TableArgument.Build(buildContext, buildArgs);
TryThrow(buildContext);
StringBuilder sql = Text.GenerateSql(30)
.NewLine(Keyword);
// subquery:
if (TableArgument.Original is View)
{
sql.S().Append(Text.LeftBracket)
.Append(tableSql)
.NewLine(Text.RightBracket);
}
// table:
else
{
sql.S().Append(tableSql);
}
// table with alias
if (_alias != null)
{
return(sql
.S().Append(Text.As)
.S().Append(Filter.Delimit(_alias.Name))
.ToString());
}
else
{
return(sql.ToString());
}
}
internal DataParamChainer(Chainer prev, string paramName, DT dt, TableArgument udt)
: base(prev, paramName, dt)
{
var root = GetRoot();
int ordinal = root.AllParams.Count;
Param = new Variable(ordinal, paramName, dt, udt, IdentifierType.Param);
GetRoot().TryAddParamOrThrow(Param, false);
}
/// <summary>
/// Initializes a new instance of the DataType class.
/// </summary>
/// <param name="dt">Is the QueryTalk's designer type.</param>
/// <param name="userDefinedType">A user-defined type.</param>
/// <param name="check">A flag indicating whether the data type definition check is done.</param>
public DataType(DT dt, TableArgument userDefinedType, bool check = true)
: this(dt)
{
Udt = userDefinedType;
if (check && !CheckParamDef(Text.Method.SysUdt, out _exception))
{
throw _exception;
}
}
internal TruncateTableChainer(Chainer prev, TableArgument table)
: base(prev)
{
CheckNullAndThrow(Arg(() => table, table));
Build = (buildContext, buildArgs) =>
{
return(Text.GenerateSql(50)
.NewLine(Text.TruncateTable).S()
.Append(table.Build(buildContext, buildArgs))
.Terminate()
.ToString());
};
}
private void ProcessTable(
BuildContext buildContext,
BuildArgs buildArgs,
TableArgument table,
StringBuilder sql)
{
sql.AppendLine()
.Append(Text.Select).S()
.Append(Text.Asterisk).S()
.Append(Text.From).S()
.Append(table.Build(buildContext, buildArgs))
.Terminate();
TryThrow(table.Exception);
}
// ctor for user-defined table type
internal TableParamChainer(Chainer prev, string paramName, DT dt, TableArgument nameType)
: base(prev, paramName, dt)
{
var root = GetRoot();
int ordinal = root.AllParams.Count;
Param = new Variable(ordinal, paramName, dt, nameType, IdentifierType.Param);
if (Param.Exception != null)
{
Param.Exception.Extra = Text.Free.UdttNameArgumentExtra;
TryThrow(Param.Exception);
}
root.TryAddParamOrThrow(Param, false);
}
// ctor for bulk tables (bulk insert)
internal TableParamChainer(Chainer prev, TableArgument bulkTable)
: base(prev, bulkTable.Sql, DT.BulkTable)
{
CheckNullAndThrow(Arg(() => bulkTable, bulkTable));
bulkTable.TryThrow();
var root = GetRoot();
int ordinal = root.AllParams.Count;
Param = new Variable(ordinal, bulkTable.Sql, DT.BulkTable, bulkTable, IdentifierType.Param);
if (Param.Exception != null)
{
Param.Exception.Extra = Text.Free.TempTableParamExtra;
TryThrow(Param.Exception);
}
root.TryAddParamOrThrow(Param, false);
}
internal static Result ExecuteBulkInsert(Assembly client, DataTable data, TableArgument table, ConnectBy connectBy)
{
table.TryThrow(Text.Method.BulkInsertGo);
if (data == null)
{
throw new QueryTalkException("Crud.GoBulkInsert", QueryTalkExceptionType.ArgumentNull, "data = null", Text.Method.BulkInsertGo)
.SetObjectName(table.Sql);
}
if (data.Rows.Count == 0)
{
return(new Result(false, 0));
}
try
{
ConnectionKey connKey = null;
if (connectBy != null)
{
connKey = ((IConnectable)connectBy).ConnectionKey;
}
var connectionString = ConnectionManager.InvokeConnectionFunc(client, connKey).ConnectionString;
using (SqlConnection cn = new SqlConnection(connectionString))
{
cn.Open();
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(cn))
{
bulkCopy.DestinationTableName = table.Sql;
bulkCopy.WriteToServer(data);
}
}
return(new Result(true, data.Rows.Count));
}
catch (QueryTalkException ex)
{
ex.Method = Text.Method.BulkInsertGo;
throw;
}
}
internal SetIdentityInsertChainer(Chainer prev, TableArgument table, bool setOn)
: base(prev)
{
CheckNullAndThrow(Arg(() => table, table));
Build = (buildContext, buildArgs) =>
{
var sql = Text.GenerateSql(70)
.NewLine(Text.SetIdentityInsert).S()
.Append(table.Build(buildContext, buildArgs)).S()
.Append((bool)setOn ? Text.On : Text.Off)
.Terminate()
.ToString();
TryThrow(buildContext);
return(sql);
};
}
internal Variable(long ordinal, string name, DT dt, TableArgument nameType, IdentifierType variableType)
: this(ordinal, name, variableType)
{
if (nameType.IsUndefined())
{
_exception = new QueryTalkException(this, QueryTalkExceptionType.ArgumentNull,
"userDefinedType = undefined", Text.Method.Param);
return;
}
if (dt == DT.View && nameType != null)
{
dt = Wall.DT.Udtt;
}
_dt = dt;
Ordinal = ordinal;
Name = name;
_nameType = nameType;
_exception = nameType.Exception;
}
internal string BuildCte(BuildContext buildContext, BuildArgs buildArgs, bool isFirstCte)
{
var sql = Text.GenerateSql(500);
if (isFirstCte)
{
sql.NewLine(Text.With).S();
}
else
{
sql.NewLine(Text.Comma);
}
sql.Append(Filter.Delimit(Alias.Name))
.Append(Text._As_)
.NewLine(Text.LeftBracket)
.Append(TableArgument.Build(buildContext, buildArgs))
.NewLine(Text.RightBracket);
return(sql.ToString());
}
internal OutputIntoChainer(Chainer prev, TableArgument target)
: base(prev)
{
CheckNullAndThrow(Arg(() => target, target));
((IOutput)prev.Prev).OutputTarget = target;
}
internal DeclareChainer(Chainer prev, string variableName, DT dt, TableArgument udt)
: base(prev)
{
_variableName = variableName;
Initialize(dt, udt);
}
/// <summary>
/// Executes a bulk insert.
/// </summary>
/// <param name="data">The data to be inserted.</param>
/// <param name="table">Is a target table where the data is inserted.</param>
public void BulkInsertGo(Result <DataTable> data, TableArgument table)
{
PublicInvoker.Call(Assembly.GetCallingAssembly(), (ca) =>
Importer.ExecuteBulkInsert(ca, data.ToDataTable(), table, this));
}
