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
163 lines (137 loc) · 7.04 KB
/
SimpleReferenceFormatter.cs
File metadata and controls
163 lines (137 loc) · 7.04 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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
using System.ComponentModel;
namespace Simple.Data.Ado
{
using System;
using System.Collections.Generic;
using System.Text;
using Schema;
public class SimpleReferenceFormatter
{
private readonly IFunctionNameConverter _functionNameConverter;
private readonly DatabaseSchema _schema;
private readonly ICommandBuilder _commandBuilder;
public SimpleReferenceFormatter(DatabaseSchema schema, ICommandBuilder commandBuilder) : this(schema, commandBuilder, null)
{
}
public SimpleReferenceFormatter(DatabaseSchema schema, ICommandBuilder commandBuilder, IFunctionNameConverter functionNameConverter)
{
_schema = schema;
_commandBuilder = commandBuilder;
_functionNameConverter = functionNameConverter ?? new FunctionNameConverter();
}
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.");
}
// ReSharper disable UnusedParameter.Local
private string TryFormatAsAllColumnsReference(AllColumnsSpecialReference allColumnsSpecialReference, bool excludeAlias)
// ReSharper restore UnusedParameter.Local
{
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) : _commandBuilder.AddParameter(obj).Name;
}
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),
_schema.QuoteObjectName(mathReference.GetAlias()));
}
private string MathOperatorToString(MathOperator @operator)
{
switch (@operator)
{
case MathOperator.Add:
return _schema.Operators.Add;
case MathOperator.Subtract:
return _schema.Operators.Subtract;
case MathOperator.Multiply:
return _schema.Operators.Multiply;
case MathOperator.Divide:
return _schema.Operators.Divide;
case MathOperator.Modulo:
return _schema.Operators.Modulo;
default:
throw new InvalidEnumArgumentException("Invalid MathOperator specified.");
}
}
private string TryFormatAsFunctionReference(FunctionReference functionReference, bool excludeAlias)
{
if (ReferenceEquals(functionReference, null)) return null;
var sqlName = _functionNameConverter.ConvertToSqlName(functionReference.Name);
string formatted;
if (sqlName.Equals("countdistinct", StringComparison.OrdinalIgnoreCase))
{
formatted = string.Format("count(distinct {0})", FormatColumnClause(functionReference.Argument));
}
else
{
formatted = string.Format("{0}({1}{2})", sqlName,
FormatColumnClause(functionReference.Argument),
FormatAdditionalArguments(functionReference.AdditionalArguments));
}
if ((!excludeAlias) && functionReference.GetAlias() != null)
{
formatted = string.Format("{0} AS {1}", formatted, _schema.QuoteObjectName(functionReference.GetAlias()));
}
return formatted;
}
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);
}
return string.Format("{0}.{1} AS {2}", tableName, column.QuotedName,
_schema.QuoteObjectName(objectReference.GetAlias()));
}
}
}