public PreparedContext(uint statementId, SqlStringTemplate sqlStringTemplate, TableHeader tableHeader)
{
this.statementId = statementId;
_sqlStringTemplate = sqlStringTemplate;
_keys = _sqlStringTemplate.GetValueKeys();
//----------------------------------------------
_tableHeader = tableHeader;
int serverFieldCount = tableHeader.ColumnCount;
//add field information to _keys
List <FieldPacket> fields = tableHeader.GetFields();
//----------------------------------------------
int bindingCount = 0;
for (int i = 0; i < serverFieldCount; ++i)
{
FieldPacket f = fields[i];
if (f.name == "?") //
{
//this is binding field
_keys[bindingCount].fieldInfo = f;
bindingCount++;
}
}
//some field from server is not binding field
//so we select only binding field
if (bindingCount != _keys.Count)
{
throw new Exception("key num not matched!");
}
//-------------------------------------------------
_preparedValues = new MyStructData[bindingCount]; //***
}
bool Parse_Field_Content(MySqlStreamReader reader)
{
if (!reader.Ensure(_currentHeader.ContentLength)) //check if length is enough to parse
{
#if DEBUG
reader.dbugMonitorData1 = true;
#endif
return(_needMoreData = true);
}
var fieldPacket = new FieldPacket(_currentHeader, this._isProtocol41);
fieldPacket.ParsePacketContent(reader);
fieldPacket.FieldIndex = _tableHeader.ColumnCount; //set this before add to field list
_tableHeader.AddField(fieldPacket);
#if DEBUG
//TODO:review here
if (fieldPacket.dbugFailure)
{
throw new NotSupportedException();
}
#endif
//next state => field header of next field
_parsingState = ResultPacketState.Field_Header;
return(false);
}
public void Prepare()
{
//prepare sql query
_prepareContext = null;
if (_cmdParams == null)
{
return;
}
_writer.Reset();
string realSql = _sqlStrTemplate.BindValues(_cmdParams, true);
ComPrepareStatementPacket preparePacket = new ComPrepareStatementPacket(realSql);
preparePacket.WritePacket(_writer);
SendPacket(_writer.ToArray());
OkPrepareStmtPacket okPreparePacket = new OkPrepareStmtPacket();
okPreparePacket = ParsePrepareResponse();
if (okPreparePacket != null)
{
_prepareContext = new PreparedContext(okPreparePacket.statement_id, _sqlStrTemplate);
if (okPreparePacket.num_params > 0)
{
var tableHeader = new TableHeader();
tableHeader.TypeCast = typeCast;
tableHeader.NestTables = nestTables;
tableHeader.ConnConfig = _conn.config;
for (int i = 0; i < okPreparePacket.num_params; i++)
{
//no meaing for each field?
FieldPacket field = ParseColumn();
tableHeader.AddField(field);
}
//set table after the table is ready!
_prepareContext.Setup(tableHeader);
ParseEOF();
}
if (okPreparePacket.num_columns > 0)
{
_tableHeader = new TableHeader();
_tableHeader.TypeCast = typeCast;
_tableHeader.NestTables = nestTables;
_tableHeader.ConnConfig = _conn.config;
for (int i = 0; i < okPreparePacket.num_columns; i++)
{
FieldPacket field = ParseColumn();
_tableHeader.AddField(field);
}
ParseEOF();
}
}
}
FieldPacket ParseColumn()
{
FieldPacket fieldPacket = new FieldPacket(_conn.IsProtocol41);
fieldPacket.ParsePacketHeader(_parser);
_receiveBuffer = CheckLimit(fieldPacket.GetPacketLength(), _receiveBuffer, DEFAULT_BUFFER_SIZE);
fieldPacket.ParsePacket(_parser);
CheckBeforeParseHeader(_receiveBuffer);
return(fieldPacket);
}
bool Parse_ColumnField_Content(MySqlStreamReader reader)
{
if (!reader.Ensure(_currentHeader.ContentLength))
{
return(_needMoreData = true);
}
var field = new FieldPacket(_currentHeader, _isProtocol41);
field.ParsePacketContent(reader);
field.FieldIndex = _tableHeader.ColumnCount; //set this before add to field list
_tableHeader.AddField(field);
//back to field header
_parsingState = PrepareResponseParseState.ColumnField_Header;
return(false);
}
void ParseResultSet()
{
ResultSetHeaderPacket resultPacket = new ResultSetHeaderPacket();
resultPacket.ParsePacket(_parser);
this._tableHeader = new TableHeader();
_tableHeader.TypeCast = typeCast;
_tableHeader.NestTables = nestTables;
_tableHeader.ConnConfig = _conn.config;
bool protocol41 = _conn.IsProtocol41;
while (_receiveBuffer[_parser.Position + 4] != EOF_CODE)
{
FieldPacket fieldPacket = ParseColumn();
_tableHeader.AddField(fieldPacket);
}
EofPacket fieldEof = ParseEOF();
//-----
_lastRow = new RowDataPacket(_tableHeader);
}
public void AddField(FieldPacket field)
{
_fields.Add(field);
}
public void AddField(FieldPacket field)
{
_fields.Add(field);
}
/// <summary>
/// read a data cell with type cast
/// </summary>
/// <param name="parser"></param>
/// <param name="fieldPacket"></param>
/// <param name="data"></param>
void ReadCellWithTypeCast(PacketParser parser, FieldPacket fieldPacket, ref MyStructData data)
{
string numberString;
Types type = (Types)fieldPacket.type;
switch (type)
{
case Types.TIMESTAMP:
case Types.DATE:
case Types.DATETIME:
case Types.NEWDATE:
_stbuilder.Length = 0; //clear
string dateString = parser.ParseLengthCodedString();
data.myString = dateString;
if (_config.dateStrings)
{
//return new FieldData<string>(type, dateString);
//data.myString = dateString;
data.type = type;
return;
}
if (dateString == null)
{
data.type = Types.NULL;
return;
}
// var originalString = dateString;
// if (field.type === Types.DATE) {
// dateString += ' 00:00:00';
// }
_stbuilder.Append(dateString);
//string originalString = dateString;
if (fieldPacket.type == (int)Types.DATE)
{
_stbuilder.Append(" 00:00:00");
}
// if (timeZone !== 'local') {
// dateString += ' ' + timeZone;
// }
if (!_isLocalTimeZone)
{
_stbuilder.Append(' ' + _config.timezone);
}
//var dt;
// dt = new Date(dateString);
// if (isNaN(dt.getTime())) {
// return originalString;
// }
data.myDateTime = DateTime.Parse(_stbuilder.ToString());
data.type = type;
return;
case Types.TINY:
case Types.SHORT:
case Types.LONG:
case Types.INT24:
case Types.YEAR:
//TODO: review here,
data.myString = numberString = parser.ParseLengthCodedString();
if (numberString == null || (fieldPacket.zeroFill && numberString[0] == '0') || numberString.Length == 0)
{
data.type = Types.NULL;
}
else
{
data.myInt32 = Convert.ToInt32(numberString);
data.type = type;
}
return;
case Types.FLOAT:
case Types.DOUBLE:
data.myString = numberString = parser.ParseLengthCodedString();
if (numberString == null || (fieldPacket.zeroFill && numberString[0] == '0'))
{
data.myString = numberString;
data.type = Types.NULL;
}
else
{
data.myDouble = Convert.ToDouble(numberString);
data.type = type;
}
return;
// return (numberString === null || (field.zeroFill && numberString[0] == "0"))
// ? numberString : Number(numberString);
case Types.NEWDECIMAL:
case Types.LONGLONG:
// numberString = parser.parseLengthCodedString();
// return (numberString === null || (field.zeroFill && numberString[0] == "0"))
// ? numberString
// : ((supportBigNumbers && (bigNumberStrings || (Number(numberString) > IEEE_754_BINARY_64_PRECISION)))
// ? numberString
// : Number(numberString));
data.myString = numberString = parser.ParseLengthCodedString();
if (numberString == null || (fieldPacket.zeroFill && numberString[0] == '0'))
{
data.myString = numberString;
data.type = Types.NULL;
}
else if (_config.supportBigNumbers && (_config.bigNumberStrings || (Convert.ToInt64(numberString) > IEEE_754_BINARY_64_PRECISION)))
{
//store as string ?
//TODO: review here again
data.myString = numberString;
data.type = type;
throw new NotSupportedException();
}
else if (type == Types.LONGLONG)
{
data.myInt64 = Convert.ToInt64(numberString);
data.type = type;
}
else //decimal
{
data.myDecimal = Convert.ToDecimal(numberString);
data.type = type;
}
return;
case Types.BIT:
data.myBuffer = parser.ParseLengthCodedBuffer();
data.type = type;
return;
// return parser.parseLengthCodedBuffer();
case Types.STRING:
case Types.VAR_STRING:
case Types.TINY_BLOB:
case Types.MEDIUM_BLOB:
case Types.LONG_BLOB:
case Types.BLOB:
if (fieldPacket.charsetNr == (int)CharSets.BINARY)
{
data.myBuffer = parser.ParseLengthCodedBuffer(); //CodedBuffer
data.type = type;
}
else
{
data.myString = parser.ParseLengthCodedString(); //codeString
data.type = type;
}
return;
// return (field.charsetNr === Charsets.BINARY)
// ? parser.parseLengthCodedBuffer()
// : parser.parseLengthCodedString();
case Types.GEOMETRY:
//TODO: unfinished
data.type = Types.GEOMETRY;
return;
default:
data.myString = parser.ParseLengthCodedString();
data.type = type;
return;
}
}
void ParseValues(PacketParser parser, FieldPacket fieldInfo, ref MyStructData myData)
{
Types fieldType = (Types)fieldInfo.type;
switch (fieldType)
{
case Types.TIMESTAMP: //
case Types.DATE: //
case Types.DATETIME: //
case Types.NEWDATE: //
myData.myDateTime = parser.ParseLengthCodedDateTime();
myData.type = fieldType;
break;
case Types.TINY: //length = 1;
myData.myInt32 = parser.ParseUnsigned1();
myData.type = fieldType;
break;
case Types.SHORT: //length = 2;
case Types.YEAR: //length = 2;
myData.myInt32 = (int)parser.ParseUnsigned2();
myData.type = fieldType;
break;
case Types.INT24:
case Types.LONG: //length = 4;
myData.myInt32 = (int)parser.ParseUnsigned4();
myData.type = fieldType;
break;
case Types.FLOAT:
myData.myDouble = parser.ParseFloat();
myData.type = fieldType;
break;
case Types.DOUBLE:
myData.myDouble = parser.ParseDouble();
myData.type = fieldType;
break;
case Types.NEWDECIMAL:
myData.myDecimal = parser.ParseDecimal();
myData.type = fieldType;
break;
case Types.LONGLONG:
myData.myInt64 = parser.ParseInt64();
myData.type = fieldType;
break;
case Types.STRING:
case Types.VARCHAR:
case Types.VAR_STRING:
myData.myString = parser.ParseLengthCodedString();
myData.type = fieldType;
break;
case Types.TINY_BLOB:
case Types.MEDIUM_BLOB:
case Types.LONG_BLOB:
case Types.BLOB:
case Types.BIT:
myData.myBuffer = parser.ParseLengthCodedBuffer();
myData.type = fieldType;
break;
case Types.GEOMETRY:
default:
myData.myBuffer = parser.ParseLengthCodedBuffer();
myData.type = Types.NULL;
break;
}
}
internal MySqlFieldDefinition(FieldPacket fieldPacket)
{
this.fieldPacket = fieldPacket;
}
bool Parse_ColumnField_Content(MySqlStreamReader reader)
{
if (!reader.Ensure(_currentHeader.ContentLength))
{
return _needMoreData = true;
}
var field = new FieldPacket(_currentHeader, _isProtocol41);
field.ParsePacketContent(reader);
field.FieldIndex = _tableHeader.ColumnCount; //set this before add to field list
_tableHeader.AddField(field);
//back to field header
_parsingState = PrepareResponseParseState.ColumnField_Header;
return false;
}
bool Parse_Field_Content(MySqlStreamReader reader)
{
if (!reader.Ensure(_currentHeader.ContentLength)) //check if length is enough to parse
{
#if DEBUG
reader.dbugMonitorData1 = true;
#endif
return _needMoreData = true;
}
var fieldPacket = new FieldPacket(_currentHeader, this._isProtocol41);
fieldPacket.ParsePacketContent(reader);
fieldPacket.FieldIndex = _tableHeader.ColumnCount; //set this before add to field list
_tableHeader.AddField(fieldPacket);
#if DEBUG
//TODO:review here
if (fieldPacket.dbugFailure)
{
throw new NotSupportedException();
}
#endif
//next state => field header of next field
_parsingState = ResultPacketState.Field_Header;
return false;
}
