-
Notifications
You must be signed in to change notification settings - Fork 649
/
HanaProcessor.cs
198 lines (153 loc) · 6.9 KB
/
HanaProcessor.cs
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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text.RegularExpressions;
using FluentMigrator.Expressions;
using FluentMigrator.Runner.Generators;
using FluentMigrator.Runner.Generators.Hana;
using FluentMigrator.Runner.Helpers;
using FluentMigrator.Runner.Initialization;
using JetBrains.Annotations;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
namespace FluentMigrator.Runner.Processors.Hana
{
public class HanaProcessor : GenericProcessorBase
{
[Obsolete]
public HanaProcessor(IDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, IDbFactory factory)
: base(connection, factory, generator, announcer, options)
{
}
public HanaProcessor(
[NotNull] HanaDbFactory factory,
[NotNull] HanaGenerator generator,
[NotNull] ILogger<HanaProcessor> logger,
[NotNull] IOptionsSnapshot<ProcessorOptions> options,
[NotNull] IConnectionStringAccessor connectionStringAccessor)
: base(() => factory.Factory, generator, logger, options.Value, connectionStringAccessor)
{
}
public override string DatabaseType => ProcessorId.Hana;
public override IList<string> DatabaseTypeAliases { get; } = new List<string>();
public IQuoter Quoter => ((HanaGenerator)Generator).Quoter;
public override bool SchemaExists(string schemaName)
{
return false;
}
public override bool TableExists(string schemaName, string tableName)
{
if (string.IsNullOrEmpty(tableName))
throw new ArgumentNullException(nameof(tableName));
return Exists(
"SELECT 1 FROM TABLES WHERE SCHEMA_NAME = CURRENT_SCHEMA AND TABLE_NAME = '{0}'",
FormatHelper.FormatSqlEscape(Quoter.UnQuote(tableName)));
}
public override bool ColumnExists(string schemaName, string tableName, string columnName)
{
if (tableName == null)
throw new ArgumentNullException(nameof(tableName));
if (columnName == null)
throw new ArgumentNullException(nameof(columnName));
return Exists("SELECT 1 FROM TABLE_COLUMNS WHERE SCHEMA_NAME = CURRENT_SCHEMA AND upper(TABLE_NAME) = '{0}' AND upper(COLUMN_NAME) = '{1}'",
FormatHelper.FormatSqlEscape(Quoter.UnQuote(tableName).ToUpper()),
FormatHelper.FormatSqlEscape(Quoter.UnQuote(columnName).ToUpper()));
}
public override bool ConstraintExists(string schemaName, string tableName, string constraintName)
{
if (tableName == null)
throw new ArgumentNullException(nameof(tableName));
if (constraintName == null)
throw new ArgumentNullException(nameof(constraintName));
if (constraintName.Length == 0)
return false;
return Exists("SELECT 1 FROM CONSTRAINTS WHERE SCHEMA_NAME = CURRENT_SCHEMA and upper(CONSTRAINT_NAME) = '{0}'",
FormatHelper.FormatSqlEscape(Quoter.UnQuote(constraintName).ToUpper()));
}
public override bool IndexExists(string schemaName, string tableName, string indexName)
{
if (tableName == null)
throw new ArgumentNullException(nameof(tableName));
if (indexName == null)
throw new ArgumentNullException(nameof(indexName));
if (indexName.Length == 0)
return false;
return Exists("SELECT 1 FROM INDEXES WHERE SCHEMA_NAME = CURRENT_SCHEMA AND upper(INDEX_NAME) = '{0}'",
FormatHelper.FormatSqlEscape(Quoter.UnQuote(indexName).ToUpper()));
}
public override bool SequenceExists(string schemaName, string sequenceName)
{
if (sequenceName == null)
throw new ArgumentNullException(nameof(sequenceName));
if (string.IsNullOrEmpty(sequenceName))
return false;
return Exists("SELECT 1 FROM SEQUENCES WHERE SCHEMA_NAME = CURRENT_SCHEMA and upper(SEQUENCE_NAME) = '{0}'",
FormatHelper.FormatSqlEscape(Quoter.UnQuote(sequenceName).ToUpper()));
}
public override bool DefaultValueExists(string schemaName, string tableName, string columnName, object defaultValue)
{
return false;
}
public override void Execute(string template, params object[] args)
{
Process(string.Format(template, args));
}
public override bool Exists(string template, params object[] args)
{
if (template == null)
throw new ArgumentNullException(nameof(template));
EnsureConnectionIsOpen();
var querySql = string.Format(template, args);
Logger.LogSql($"{querySql};");
using (var command = CreateCommand(string.Format(template, args)))
using (var reader = command.ExecuteReader())
{
return reader.Read();
}
}
public override DataSet ReadTableData(string schemaName, string tableName)
{
if (tableName == null)
throw new ArgumentNullException(nameof(tableName));
return Read("SELECT * FROM {0}", Quoter.QuoteTableName(tableName, schemaName));
}
public override DataSet Read(string template, params object[] args)
{
if (template == null)
throw new ArgumentNullException(nameof(template));
EnsureConnectionIsOpen();
using (var command = CreateCommand(string.Format(template, args)))
using (var reader = command.ExecuteReader())
{
return reader.ReadDataSet();
}
}
public override void Process(PerformDBOperationExpression expression)
{
Logger.LogSay("Performing DB Operation");
if (Options.PreviewOnly)
return;
EnsureConnectionIsOpen();
expression.Operation?.Invoke(Connection, Transaction);
}
protected override void Process(string sql)
{
Logger.LogSql(sql);
if (Options.PreviewOnly || string.IsNullOrEmpty(sql))
return;
EnsureConnectionIsOpen();
var batches = Regex.Split(sql, @"^\s*;\s*$", RegexOptions.Multiline)
.Where(x => !string.IsNullOrEmpty(x))
.Select(c => c.Trim());
foreach (var batch in batches)
{
var batchCommand = batch.EndsWith(";")
? batch.Remove(batch.Length - 1)
: batch;
using (var command = CreateCommand(batchCommand))
command.ExecuteNonQuery();
}
}
}
}