public virtual object GetValue()
{
if (!RowData.Keys.Contains(FieldName) || RowData[FieldName] == null || RowData[FieldName].ToString().IsNullOrEmpty())
{
RowData[FieldName] = DefaultValue.IsNullOrEmpty() ? string.Empty : DefaultValue;
}
object result = RowData[FieldName];
if (ColumnConverter != null)
{
result = ColumnConverter.Converter(FieldName, result, RowData);
}
else
{
if (!DataFormatString.IsNullOrEmpty() && !HtmlEncode)
{
if (!DataFormatFields.IsNullOrEmpty())
{
var dataFields = DataFormatFields.Split(',');
object[] param = new object[dataFields.Length];
for (int i = 0; i < dataFields.Length; i++)
{
param[i] = RowData[dataFields[i]];
}
result = string.Format(CultureInfo.CurrentCulture, DataFormatString, param);
}
else
{
result = string.Format(CultureInfo.CurrentCulture, DataFormatString, new object[] { result });
}
}
}
return result;
}
public ColumnLoader(SchemaExtendedReader schemaReader)
{
_sr = schemaReader;
var cols = _sr.Columns(null);
_noColumns = (cols.Rows.Count == 0);
_columnConverter = new ColumnConverter(cols);
}
/// <summary>
///
/// </summary>
/// <param name="column"></param>
/// <param name="start"></param>
/// <param name="end"></param>
public void Read(int column, int start, int end)
{
string columnName = ColumnConverter.Get(column);
if (this.storedValues.ContainsKey(columnName))
{
this.storedValues.Remove(columnName);
}
if (this.worksheet != null)
{
Dictionary <int, string> tempDictionary = new Dictionary <int, string>();
for (int i = start; i <= end; i++)
{
Range range = this.worksheet.Cells[i, column] as Range;
string cellValue = range.Value != null?range.Value.ToString() : "null";
tempDictionary.Add(i, cellValue);
}
this.storedValues.Add(columnName, tempDictionary);
}
else
{
this.logger.Error($"The current worksheet seems to be null. Unable to read \"{this.excelPath}\".");
}
}
public override IList <DatabaseColumn> Columns(string tableName)
{
var dt = _schemaReader.Columns(tableName);
var columnConverter = new ColumnConverter(dt);
var cols = columnConverter.Columns().ToList();
return(cols);
}
public ColumnLoader(SchemaExtendedReader schemaReader)
{
_sr = schemaReader;
var cols = _sr.Columns(null);
_noColumns = (cols.Rows.Count == 0);
_columnConverter = new ColumnConverter(cols);
}
public IEnumerable<DatabaseColumn> Load(string tableName, string schemaName)
{
if (string.IsNullOrEmpty(tableName)) throw new ArgumentNullException("tableName", "must have tableName");
//schemaName may be null for databases that don't have schemas
if (_noColumns)
{
//have to get columns for specific table
var cols = _sr.Columns(tableName);
_columnConverter = new ColumnConverter(cols);
}
return _columnConverter.Columns(tableName, schemaName);
}
public static Table AdaptTableFromJson(string Json)
{
JToken JTable = JToken.Parse(Json);
Table table = TableConverter.ConvertWithName(JTable);
JToken JColumns = JTable["Columns"];
List <Column> columns = new List <Column>();
foreach (JToken Jcolumn in JColumns)
{
Column column = ColumnConverter.Convert(Jcolumn);
columns.Add(column);
}
table.Columns = new ColumnCollection(columns);
return(table);
}
public IEnumerable <DatabaseColumn> Load(string tableName)
{
if (string.IsNullOrEmpty(tableName))
{
throw new ArgumentNullException("tableName", "must have tableName");
}
if (_noColumns)
{
//have to get columns for specific table
var cols = _sr.Columns(tableName);
_columnConverter = new ColumnConverter(cols);
}
return(_columnConverter.Columns(tableName));
}
string FormatDateConverter(ColumnConverter columnConverter, string converter, string unit, string value)
{
if (columnConverter.IsInstanceColumn)
{
if (string.IsNullOrWhiteSpace(value))
{
converter = string.Format(converter, string.Format("DATE({0},{1} ' {2}')", "{0}", value, unit));
}
else
{
converter = string.Format(converter, string.Format("DATE({0},{1} || ' {2}')", "{0}", value, unit));
}
}
else
{
converter = string.Format(converter, string.Format("DATE('{0}',{1} || ' {2}')", value, "{0}", unit));
}
return(converter);
}
private string AddColumns(string schemaOwner, string tableName, DatabaseTable table, DataSet ds)
{
table.Columns.Clear();
var columnConverter = new ColumnConverter(ds.Tables[_schemaReader.ColumnsCollectionName]);
var databaseColumns = columnConverter.Columns(tableName, schemaOwner).ToList();
if (!databaseColumns.Any())
{
//need to define the schema
databaseColumns = columnConverter.Columns().ToList();
var first = databaseColumns.FirstOrDefault();
if (first != null)
{
//take the schema of the first we find
table.SchemaOwner = schemaOwner = first.SchemaOwner;
}
databaseColumns = columnConverter.Columns(tableName, schemaOwner).ToList();
}
table.Columns.AddRange(databaseColumns);
return schemaOwner;
}
private string AddColumns(string schemaOwner, string tableName, DatabaseTable table, DataSet ds)
{
table.Columns.Clear();
var columnConverter = new ColumnConverter(ds.Tables[_schemaReader.ColumnsCollectionName]);
var databaseColumns = columnConverter.Columns(tableName, schemaOwner).ToList();
if (!databaseColumns.Any())
{
//need to define the schema
databaseColumns = columnConverter.Columns().ToList();
var first = databaseColumns.FirstOrDefault();
if (first != null)
{
//take the schema of the first we find
table.SchemaOwner = schemaOwner = first.SchemaOwner;
}
databaseColumns = columnConverter.Columns(tableName, schemaOwner).ToList();
}
table.Columns.AddRange(databaseColumns);
return(schemaOwner);
}
/// <summary>
/// Gets all query columns from a command (assign any parameters if required)
/// </summary>
public IList <DatabaseColumn> GetQueryColumns(DbCommand command, IList <DataType> types)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
using (var rdr = command.ExecuteReader(System.Data.CommandBehavior.KeyInfo))
{
using (var colTable = rdr.GetSchemaTable())
{
var columnConverter = new ColumnConverter(colTable);
var cols = columnConverter.Columns().ToList();
// It is necessade to create a new list of DataType using connection.GetSchema(DbMetaDataCollectionNames.DataTypes)
// because the ProviderDbType in the list returned by DataTypes() is sometimes wrong.
//var readerAdapter = new DbProviderReaderAdapter(schemaParameters);
DatabaseSchemaFixer.UpdateDataTypes(types, cols);
return(cols);
}
}
}
/// <summary>
/// Gets the table. If <see cref="Owner"/> is specified, it is used.
/// </summary>
/// <param name="tableName">Name of the table. Oracle names can be case sensitive.</param>
public DatabaseTable Table(string tableName)
{
if (string.IsNullOrEmpty(tableName))
{
throw new ArgumentNullException("tableName");
}
DatabaseTable table;
using (DataSet ds = _sr.Table(tableName))
{
if (ds == null)
{
return(null);
}
if (ds.Tables.Count == 0)
{
return(null);
}
table = DatabaseSchema.FindTableByName(tableName);
if (table == null)
{
table = new DatabaseTable();
DatabaseSchema.Tables.Add(table);
}
table.Name = tableName;
table.SchemaOwner = _sr.Owner;
//columns must be done first as it is updated by the others
table.Columns.Clear();
var columnConverter = new ColumnConverter(ds.Tables[_sr.ColumnsCollectionName]);
table.Columns.AddRange(columnConverter.Columns());
if (ds.Tables.Contains(_sr.PrimaryKeysCollectionName))
{
var converter = new SchemaConstraintConverter(ds.Tables[_sr.PrimaryKeysCollectionName], ConstraintType.PrimaryKey);
var pkConstraints = converter.Constraints();
PrimaryKeyLogic.AddPrimaryKey(table, pkConstraints);
}
if (ds.Tables.Contains(_sr.ForeignKeysCollectionName))
{
var converter = new SchemaConstraintConverter(ds.Tables[_sr.ForeignKeysCollectionName], ConstraintType.ForeignKey);
table.AddConstraints(converter.Constraints());
}
if (ds.Tables.Contains(_sr.ForeignKeyColumnsCollectionName))
{
var fkConverter = new ForeignKeyColumnConverter(ds.Tables[_sr.ForeignKeyColumnsCollectionName]);
fkConverter.AddForeignKeyColumns(table.ForeignKeys);
}
if (ds.Tables.Contains(_sr.UniqueKeysCollectionName))
{
var converter = new SchemaConstraintConverter(ds.Tables[_sr.UniqueKeysCollectionName], ConstraintType.UniqueKey);
table.AddConstraints(converter.Constraints());
}
var indexConverter = new IndexConverter(ds.Tables[_sr.IndexColumnsCollectionName], null);
table.Indexes.AddRange(indexConverter.Indexes(tableName));
if (ds.Tables.Contains(_sr.IdentityColumnsCollectionName))
{
SchemaConstraintConverter.AddIdentity(ds.Tables[_sr.IdentityColumnsCollectionName], table);
}
}
if (DatabaseSchema.DataTypes.Count > 0)
{
DatabaseSchemaFixer.UpdateDataTypes(DatabaseSchema);
}
_sr.PostProcessing(DatabaseSchema);
return(table);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
var argsExp = node.Arguments;
var args = new List <Token>();
foreach (var argExp in argsExp)
{
args.Add(ParseArgument(argExp));
}
if (node.Object == null)
{
//静态方法调用var col = (Token)body.Result;
var method = node.Method;
if (_isColumn)
{
//string converter = "{0}";
var parameters = new List <object>();
switch (method.Name)
{
case "ToDateTime":
//if (method.DeclaringType != typeof(Convert) || argsExp.Count != 1)
//{
// throw new Exception("不支持");
//}
Token = (Token)args[0];
parameters.AddRange(args.Skip(1));
//converter = Token.Column.Converter;
//if (string.IsNullOrWhiteSpace(converter))
//{
// converter = "{0}";
//}
//switch (Token.Type)
//{
// case TokenType.Column:
// converter = string.Format(converter, "CONVERT(DATETIME,{0},211)");
// Token.Column.Converter = converter;
// break;
// default:
// throw new Exception();
//}
break;
case "Contains":
Token = (Token)args[1];
//var list = ((Token)args[0]).Object as IList<int>;
parameters.Add(args[0].Object);
parameters.AddRange(args.Skip(2).Where(x => x.Type == TokenType.Object).Select(x => x.Object));
//if (method.DeclaringType != typeof(Enumerable))
//{
// throw new Exception("不支持");
//}
//converter = string.Format(converter, "{0} in (" + string.Join(",", list) + ")");
//Token.Column.Converter = converter;
break;
default:
throw new Exception();
}
var converter = new ColumnConverter(method, parameters);
Token.Column.Converters.Push(converter);
}
else
{
Token = Token.Create(node.Method.Invoke(null, args.Select(x => x.Object).ToArray()));
}
}
else
{
var body = new MemberExpressionVisitor(Context);
body.Visit(node.Object);
if (body.Token.Type == TokenType.Column && !_isColumn)
{
//实例对象是列，参数不是列
Token = body.Token;
//string converter = Token.Column.Converter;
//if (string.IsNullOrWhiteSpace(converter))
//{
// converter = "{0}";
//}
var method = node.Method;
var argObjects = args.Select(x => x.Object);
//Token.Column.ConverterParameters.AddRange(argObjects);
Token.Column.Converters.Push(new ColumnConverter(method, argObjects.ToList(), true));
//switch (method.Name)
//{
// case "ToDateTime":
// if (method.DeclaringType != typeof(Convert) || argsExp.Count != 1)
// {
// throw new Exception("不支持");
// }
// converter = string.Format(converter, "CONVERT(DATETIME,{0},211)");
// break;
// case "Substring":
// if (method.DeclaringType != typeof(string))
// {
// throw new Exception("不支持");
// }
// if (argsExp.Count == 1)
// {
// //SubString(startIndex)
// ExpressionVisitorBase visitor = new PropertyFieldExpressionVisitor(Context);
// visitor.Visit(argsExp[0]);
// if (visitor.Token.Type != TokenType.Object)
// {
// throw new Exception("不支持");
// }
// converter = string.Format(converter, "SUBSTRING({0}," + (Convert.ToInt32(argObjects[0]) + 1) + ",LEN({0})+1-" + Convert.ToInt32(visitor.Token.Object) + ")");
// }
// else if (argsExp.Count == 2)
// {
// //SubString(startIndex,length)
// ExpressionVisitorBase startVisitor = new PropertyFieldExpressionVisitor(Context);
// startVisitor.Visit(argsExp[0]);
// if (startVisitor.Token.Type != TokenType.Object)
// {
// throw new Exception("不支持");
// }
// ExpressionVisitorBase lenVistior = new PropertyFieldExpressionVisitor(Context);
// lenVistior.Visit(argsExp[1]);
// if (lenVistior.Token.Type != TokenType.Object)
// {
// throw new Exception("不支持");
// }
// converter = string.Format(converter, "SUBSTRING({0}," + (Convert.ToInt32(startVisitor.Token.Object) + 1) + "," + Convert.ToInt32(lenVistior.Token.Object) + ")");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "Contains":
// if (method.DeclaringType == typeof(string))
// {
// converter = string.Format(converter, "CHARINDEX(@param1,{0})>0");
// Token.Column.ConverterParameters.AddRange(argObjects);
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "StartsWith":
// if (method.DeclaringType == typeof(string))
// {
// converter = string.Format(converter, "CHARINDEX(@param1,{0})=1");
// Token.Column.ConverterParameters.AddRange(argObjects);
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddDays":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(DAY,@param1,{0})");
// Token.Column.ConverterParameters.AddRange(argObjects);
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddHours":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(HOUR,@param1,{0})");
// Token.Column.ConverterParameters.AddRange(argObjects);
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddMilliseconds":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(MILLISECOND,@param1,{0})");
// Token.Column.ConverterParameters.AddRange(argObjects);
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddMinutes":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(MINUTE,@param1,{0})");
// Token.Column.ConverterParameters.AddRange(argObjects);
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddMonths":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(MONTH,@param1,{0})");
// Token.Column.ConverterParameters.AddRange(argObjects);
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddSeconds":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(SECOND,@param1,{0})");
// Token.Column.ConverterParameters.AddRange(argObjects);
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddYears":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(YEAR,@param1,{0})");
// Token.Column.ConverterParameters.AddRange(argObjects);
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// default:
// throw new Exception();
//}
//Token.Column.Converter = converter;
}
else if (body.Token.Type == TokenType.Object && !_isColumn)
{
Token = Token.Create(node.Method.Invoke(body.Token.Object, args.Select(x => x.Object).ToArray()));
}
else if (body.Token.Type == TokenType.Object && _isColumn)
{
Token = args[0];
var parameters = new List <object>();
parameters.Add(body.Token.Object);
parameters.AddRange(args.Skip(1));
Token.Column.Converters.Push(new ColumnConverter(node.Method, parameters, false));
//string converter = Token.Column.Converter;
//if (string.IsNullOrWhiteSpace(converter))
//{
// converter = "{0}";
//}
//var method = node.Method;
//switch (method.Name)
//{
// case "Contains":
// if (method.DeclaringType == typeof(string))
// {
// converter = string.Format(converter, "CHARINDEX({0},@param1)>0");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "StartsWith":
// if (method.DeclaringType == typeof(string))
// {
// converter = string.Format(converter, "CHARINDEX(@param1,{0})>0");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddDays":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(DAY,{0},@param1)");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddHours":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(HOUR,{0},@param1)");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddMilliseconds":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(MILLISECOND,{0},@param1)");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddMinutes":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(MINUTE,{0},@param1)");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddMonths":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(MONTH,{0},@param1)");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddSeconds":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(SECOND,{0},@param1)");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// case "AddYears":
// if (method.DeclaringType == typeof(DateTime))
// {
// converter = string.Format(converter, "DATEADD(YEAR,{0},@param1)");
// }
// else
// {
// throw new Exception("不支持");
// }
// break;
// default:
// throw new Exception("不支持");
//}
//Token.Column.Converter = converter;
//Token.Column.ConverterParameters.Add(body.Token.Object);
}
else
{
throw new Exception();
}
}
return(node);
}
public Cell(int cellColumn, int rowIndex)
{
this.cellColumn = new Column(ColumnConverter.Get(cellColumn));
this.cellRow = new Row(rowIndex);
}
