/// <summary>
/// This request is used to close the Statement object in the Phoenix query server identified by the given IDs.
/// </summary>
public async Task <CloseStatementResponse> CloseStatementRequestAsync(string connectionId, uint statementId, RequestOptions options)
{
CloseStatementRequest req = new CloseStatementRequest
{
ConnectionId = connectionId,
StatementId = statementId
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "CloseStatementRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"CloseStatementRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
CloseStatementResponse res = CloseStatementResponse.Parser.ParseFrom(output.WrappedMessage);
return(res);
}
}
}
/// <summary>
/// This request is used to open a new Connection in the Phoenix query server.
/// </summary>
public async Task <OpenConnectionResponse> OpenConnectionRequestAsync(string connectionId, pbc::MapField <string, string> info, RequestOptions options)
{
OpenConnectionRequest req = new OpenConnectionRequest
{
ConnectionId = connectionId,
Info = info
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "OpenConnectionRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"OpenConnectionRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
OpenConnectionResponse res = OpenConnectionResponse.Parser.ParseFrom(output.WrappedMessage);
return(res);
}
}
}
/// <summary>
/// This request is used to fetch the tables available in this database filtered by the provided criteria.
/// </summary>
public async Task <ResultSetResponse> TablesRequestAsync(string catalog, string schemaPattern, string tableNamePattern, pbc::RepeatedField <string> typeList, bool hasTypeList, string connectionId)
{
TablesRequest req = new TablesRequest
{
Catalog = catalog,
SchemaPattern = schemaPattern,
TableNamePattern = tableNamePattern,
HasTypeList = hasTypeList,
ConnectionId = connectionId
};
req.TypeList.AddRange(typeList);
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "TablesRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray()))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"TablesRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ResultSetResponse res = ResultSetResponse.Parser.ParseFrom(output.WrappedMessage);
return(res);
}
}
}
/// <summary>
/// This request is used to fetch the columns in this database.
/// </summary>
public async Task <ResultSetResponse> ColumnsRequestAsync(string catalog, string schemaPattern, string tableNamePattern, string columnNamePattern, string connectionId, RequestOptions options)
{
ColumnsRequest req = new ColumnsRequest
{
Catalog = catalog,
SchemaPattern = schemaPattern,
TableNamePattern = tableNamePattern,
ColumnNamePattern = columnNamePattern,
ConnectionId = connectionId
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "ColumnsRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"ColumnsRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ResultSetResponse res = ResultSetResponse.Parser.ParseFrom(output.WrappedMessage);
return(res);
}
}
}
/// <summary>
/// This request is used as a short-hand for create a Statement and fetching the first batch
/// of results in a single call without any parameter substitution.
/// </summary>
public async Task <ExecuteResponse> PrepareAndExecuteRequestAsync(string connectionId, string sql, uint statementId, long maxRowsTotal, int firstFrameMaxSize, RequestOptions options)
{
PrepareAndExecuteRequest req = new PrepareAndExecuteRequest
{
Sql = sql,
ConnectionId = connectionId,
StatementId = statementId,
MaxRowsTotal = maxRowsTotal,
FirstFrameMaxSize = firstFrameMaxSize
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "PrepareAndExecuteRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"PrepareAndExecuteRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ExecuteResponse res = ExecuteResponse.Parser.ParseFrom(output.WrappedMessage);
return(res);
}
}
}
/// <summary>
/// This request is used as a short-hand for create a Statement and fetching the first batch
/// of results in a single call without any parameter substitution.
/// </summary>
public async Task<ExecuteResponse> PrepareAndExecuteRequestAsync(string connectionId, string sql, uint statementId, long maxRowsTotal, int firstFrameMaxSize, RequestOptions options)
{
PrepareAndExecuteRequest req = new PrepareAndExecuteRequest
{
Sql = sql,
ConnectionId = connectionId,
StatementId = statementId,
MaxRowsTotal = maxRowsTotal,
FirstFrameMaxSize = firstFrameMaxSize
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "PrepareAndExecuteRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"PrepareAndExecuteRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ExecuteResponse res = ExecuteResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}
/// <summary>
/// This request is used to execute a PreparedStatement, optionally with values to bind to the parameters in the Statement.
/// </summary>
public async Task <ExecuteResponse> ExecuteRequestAsync(StatementHandle statementHandle, pbc::RepeatedField <TypedValue> parameterValues, ulong firstFrameMaxSize, bool hasParameterValues, RequestOptions options)
{
ExecuteRequest req = new ExecuteRequest
{
StatementHandle = statementHandle,
ParameterValues = parameterValues,
FirstFrameMaxSize = firstFrameMaxSize,
HasParameterValues = hasParameterValues
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "ExecuteRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"ExecuteRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
statementHandle.ConnectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ExecuteResponse res = ExecuteResponse.Parser.ParseFrom(output.WrappedMessage);
return(res);
}
}
}
/// <summary>
/// This request is used to execute a batch of updates against a PreparedStatement.
/// </summary>
public async Task <ExecuteBatchResponse> ExecuteBatchRequestAsync(string connectionId, uint statementId, pbc::RepeatedField <UpdateBatch> updates)
{
ExecuteBatchRequest req = new ExecuteBatchRequest
{
ConnectionId = connectionId,
StatementId = statementId
};
req.Updates.AddRange(updates);
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "ExecuteBatchRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray()))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"ExecuteBatchRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ExecuteBatchResponse res = ExecuteBatchResponse.Parser.ParseFrom(output.WrappedMessage);
return(res);
}
}
}
/// <summary>
/// This request is used to fetch a batch of rows from a Statement previously created.
/// </summary>
public async Task <FetchResponse> FetchRequestAsync(string connectionId, uint statementId, ulong offset, int frameMaxSize)
{
FetchRequest req = new FetchRequest
{
ConnectionId = connectionId,
StatementId = statementId,
Offset = offset,
FrameMaxSize = frameMaxSize
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "FetchRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray()))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"FetchRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
FetchResponse res = FetchResponse.Parser.ParseFrom(output.WrappedMessage);
return(res);
}
}
}
/// <summary>
/// This request is used to open a new Connection in the Phoenix query server.
/// </summary>
public async Task<OpenConnectionResponse> OpenConnectionRequestAsync(string connectionId, pbc::MapField<string, string> info, RequestOptions options)
{
OpenConnectionRequest req = new OpenConnectionRequest
{
ConnectionId = connectionId,
Info = info
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "OpenConnectionRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"OpenConnectionRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
OpenConnectionResponse res = OpenConnectionResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}
/// <summary>
/// This request is used to execute a batch of updates against a PreparedStatement.
/// </summary>
public async Task<ExecuteBatchResponse> ExecuteBatchRequestAsync(string connectionId, uint statementId, pbc::RepeatedField<UpdateBatch> updates, RequestOptions options)
{
ExecuteBatchRequest req = new ExecuteBatchRequest
{
ConnectionId = connectionId,
StatementId = statementId,
Updates = updates
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "ExecuteBatchRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"ExecuteBatchRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ExecuteBatchResponse res = ExecuteBatchResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}
/// <summary>
/// This request is used to fetch a batch of rows from a Statement previously created.
/// </summary>
public async Task<FetchResponse> FetchRequestAsync(string connectionId, uint statementId, ulong offset, int frameMaxSize, RequestOptions options)
{
FetchRequest req = new FetchRequest
{
ConnectionId = connectionId,
StatementId = statementId,
Offset = offset,
FrameMaxSize = frameMaxSize
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "FetchRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"FetchRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
FetchResponse res = FetchResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}
/// <summary>
/// This request is used to fetch the columns in this database.
/// </summary>
public async Task<ResultSetResponse> ColumnsRequestAsync(string catalog, string schemaPattern, string tableNamePattern, string columnNamePattern, string connectionId, RequestOptions options)
{
ColumnsRequest req = new ColumnsRequest
{
Catalog = catalog,
SchemaPattern = schemaPattern,
TableNamePattern = tableNamePattern,
ColumnNamePattern = columnNamePattern,
ConnectionId = connectionId
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "ColumnsRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"ColumnsRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ResultSetResponse res = ResultSetResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}
/// <summary>
/// This request is used to execute a PreparedStatement, optionally with values to bind to the parameters in the Statement.
/// </summary>
public async Task<ExecuteResponse> ExecuteRequestAsync(StatementHandle statementHandle, pbc::RepeatedField<TypedValue> parameterValues, ulong firstFrameMaxSize, bool hasParameterValues, RequestOptions options)
{
ExecuteRequest req = new ExecuteRequest
{
StatementHandle = statementHandle,
ParameterValues = parameterValues,
FirstFrameMaxSize = firstFrameMaxSize,
HasParameterValues = hasParameterValues
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "ExecuteRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"ExecuteRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
statementHandle.ConnectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ExecuteResponse res = ExecuteResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}
/// <summary>
/// This request is used to ensure that the client and server have a consistent view of the database properties.
/// </summary>
public async Task<ConnectionSyncResponse> ConnectionSyncRequestAsync(string connectionId, ConnectionProperties props, RequestOptions options)
{
ConnectionSyncRequest req = new ConnectionSyncRequest
{
ConnectionId = connectionId,
ConnProps = props
};
WireMessage msg = new WireMessage
{
Name = Constants.WireMessagePrefix + "ConnectionSyncRequest",
WrappedMessage = req.ToByteString()
};
using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options))
{
if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK)
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage);
throw new WebException(
string.Format(
"ConnectionSyncRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}",
connectionId,
webResponse.WebResponse.StatusCode,
res.ToString()));
}
else
{
WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream());
ConnectionSyncResponse res = ConnectionSyncResponse.Parser.ParseFrom(output.WrappedMessage);
return res;
}
}
}
