forked from ThatRendle/Simple.Data
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathSimpleReferenceFormatter.cs
More file actions
143 lines (123 loc) · 6.38 KB
/
SimpleReferenceFormatter.cs
File metadata and controls
143 lines (123 loc) · 6.38 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
namespace Simple.Data.Ado
{
using System;
using System.Collections.Generic;
using System.Text;
using Schema;
class SimpleReferenceFormatter
{
private readonly IFunctionNameConverter _functionNameConverter = new FunctionNameConverter();
private readonly DatabaseSchema _schema;
private readonly ICommandBuilder _commandBuilder;
public SimpleReferenceFormatter(DatabaseSchema schema, ICommandBuilder commandBuilder)
{
_schema = schema;
_commandBuilder = commandBuilder;
}
public string FormatColumnClause(SimpleReference reference)
{
return FormatColumnClause(reference, false);
}
public string FormatColumnClauseWithoutAlias(SimpleReference reference)
{
return FormatColumnClause(reference, true);
}
private string FormatColumnClause(SimpleReference reference, bool excludeAlias)
{
var formatted = TryFormatAsObjectReference(reference as ObjectReference, excludeAlias)
??
TryFormatAsFunctionReference(reference as FunctionReference, excludeAlias)
??
TryFormatAsMathReference(reference as MathReference, excludeAlias)
??
TryFormatAsAllColumnsReference(reference as AllColumnsSpecialReference, excludeAlias);
if (formatted != null) return formatted;
throw new InvalidOperationException("SimpleReference type not supported.");
}
private string TryFormatAsAllColumnsReference(AllColumnsSpecialReference allColumnsSpecialReference, bool excludeAlias)
{
if (ReferenceEquals(allColumnsSpecialReference, null)) return null;
var table = _schema.FindTable(allColumnsSpecialReference.Table.GetAllObjectNamesDotted());
var tableName = string.IsNullOrWhiteSpace(allColumnsSpecialReference.GetAlias())
? table.QualifiedName
: _schema.QuoteObjectName(allColumnsSpecialReference.GetAlias());
return string.Format("{0}.*", tableName);
}
private string FormatObject(object obj)
{
var reference = obj as SimpleReference;
return reference != null ? FormatColumnClause(reference) : obj.ToString();
}
private string TryFormatAsMathReference(MathReference mathReference, bool excludeAlias)
{
if (ReferenceEquals(mathReference, null)) return null;
if (excludeAlias || mathReference.GetAlias() == null)
{
return string.Format("{0} {1} {2}", FormatObject(mathReference.LeftOperand),
MathOperatorToString(mathReference.Operator),
FormatObject(mathReference.RightOperand));
}
return string.Format("{0} {1} {2} AS {3}", FormatObject(mathReference.LeftOperand),
MathOperatorToString(mathReference.Operator),
FormatObject(mathReference.RightOperand),
mathReference.GetAlias());
}
private static string MathOperatorToString(MathOperator @operator)
{
switch (@operator)
{
case MathOperator.Add:
return "+";
case MathOperator.Subtract:
return "-";
case MathOperator.Multiply:
return "*";
case MathOperator.Divide:
return "/";
case MathOperator.Modulo:
return "%";
default:
throw new InvalidOperationException("Invalid MathOperator specified.");
}
}
private string TryFormatAsFunctionReference(FunctionReference functionReference, bool excludeAlias)
{
if (ReferenceEquals(functionReference, null)) return null;
var sqlName = _functionNameConverter.ConvertToSqlName(functionReference.Name);
if (excludeAlias || functionReference.GetAlias() == null)
{
return string.Format("{0}({1}{2})", sqlName,
FormatColumnClause(functionReference.Argument),
FormatAdditionalArguments(functionReference.AdditionalArguments));
}
return string.Format("{0}({1}{2}) AS {3}", sqlName,
FormatColumnClause(functionReference.Argument),
FormatAdditionalArguments(functionReference.AdditionalArguments),
_schema.QuoteObjectName(functionReference.GetAlias()));
}
private string FormatAdditionalArguments(IEnumerable<object> additionalArguments)
{
StringBuilder builder = null;
foreach (var additionalArgument in additionalArguments)
{
if (builder == null) builder = new StringBuilder();
builder.AppendFormat(",{0}", _commandBuilder.AddParameter(additionalArgument));
}
return builder != null ? builder.ToString() : string.Empty;
}
private string TryFormatAsObjectReference(ObjectReference objectReference, bool excludeAlias)
{
if (ReferenceEquals(objectReference, null)) return null;
var table = _schema.FindTable(objectReference.GetOwner().GetAllObjectNamesDotted());
var tableName = string.IsNullOrWhiteSpace(objectReference.GetOwner().GetAlias())
? table.QualifiedName
: _schema.QuoteObjectName(objectReference.GetOwner().GetAlias());
var column = table.FindColumn(objectReference.GetName());
if (excludeAlias || objectReference.GetAlias() == null)
return string.Format("{0}.{1}", tableName, column.QuotedName);
else
return string.Format("{0}.{1} AS {2}", tableName, column.QuotedName,
_schema.QuoteObjectName(objectReference.GetAlias()));
}
}
}