// Return a dynamicly allocated KeyInfo structure that can be used with OP_OpenRead or OP_OpenWrite to access database index pIdx.
//
// If successful, a pointer to the new structure is returned. In this case the caller is responsible for calling sqlite3DbFree(db, ) on the returned
// pointer. If an error occurs (out of memory or missing collation sequence), NULL is returned and the state of pParse updated to reflect
// the error.
internal static KeyInfo sqlite3IndexKeyinfo(Parse pParse, Index pIdx)
{
var nCol = pIdx.nColumn;
var db = pParse.db;
var pKey = new KeyInfo();
if (pKey != null)
{
pKey.db = pParse.db;
pKey.aSortOrder = new byte[nCol];
pKey.aColl = new CollSeq[nCol];
for (var i = 0; i < nCol; i++)
{
var zColl = pIdx.azColl[i];
Debug.Assert(zColl != null);
pKey.aColl[i] = sqlite3LocateCollSeq(pParse, zColl);
pKey.aSortOrder[i] = pIdx.aSortOrder[i];
}
pKey.nField = (ushort)nCol;
}
if (pParse.nErr != 0)
{
pKey = null;
sqlite3DbFree(db, ref pKey);
}
return pKey;
}
static KeyInfo ValuePair(Enum token, object value)
{
KeyInfo k=new KeyInfo();
k.ki_key=(int)(object)token;
k.ki_name=token.ToString();
return k;
}
private static ProofKeysHelper GetHelper()
{
KeyInfo current = new KeyInfo(key, modulus, exponent);
KeyInfo old = new KeyInfo(oldKey, oldModulus, oldExponent);
return new ProofKeysHelper(current, old);
}
internal KeyValue(KeyInfo key, byte[] keyBuffer)
{
if (key == null || keyBuffer == null) {
throw new ArgumentNullException();
}
if (key.Length < keyBuffer.Length) {
throw new ArgumentException();
}
this.Key = key;
this.KeyBuffer = keyBuffer;
this.ComplementCount = 0;
}
public TmKeyRec(int _buffSize, BUFF_TYPE _buffType)
{
mBuffSize = _buffSize;
mInfo = new KeyInfo();
mRecInfo = new KeyInfo[mBuffSize];
mBuffPtr = -1;
mRecSize = mRecCtr = mPlayCtr = 0;
mState = STATE.STOP;
mBuffType = _buffType;
mPad = new PAD();
mDebug = new KeyInfoDebug();
}
public KeyValue(KeyInfo key, object[] segmentValues, bool isMinimumComplement = true)
{
if (key == null || segmentValues == null) {
throw new ArgumentNullException();
}
if (segmentValues.Length == 0 || segmentValues.Length > key.Segments.Count()) {
throw new ArgumentException();
}
this.Key = key;
this.KeyBuffer = new byte[this.Key.Length];
this.SetValues(segmentValues, 0, isMinimumComplement);
}
public TmKeyRec(TmKeyRec _origin)
{
mBuffSize = _origin.mBuffSize;
mInfo = new KeyInfo(_origin.keyInfo);
// mRecInfo = (KeyInfo[])_origin.mRecInfo.Clone();
mRecInfo = new KeyInfo[_origin.mBuffSize];
Array.Copy(_origin.mRecInfo,0,mRecInfo,0,_origin.mRecSize);
mBuffPtr = _origin.mBuffPtr;
mRecSize = _origin.mRecSize;
mRecCtr = _origin.mRecCtr;
mPlayCtr = _origin.mPlayCtr;
mState = _origin.mState;
mBuffType = _origin.mBuffType;
mPad = new PAD(_origin.mPad);
mDebug = new KeyInfoDebug();
}
public uint[] OverflowIDs; // Cache of overflow page locations
#endif
#region Methods
// was:sqlite3BtreeCursorZero
public void Zero()
{
Next = null;
Prev = null;
KeyInfo = null;
RootID = 0;
_cachedRowID = 0;
Info = new MemPage.CellInfo();
Writeable = false;
AtLast = false;
ValidNKey = false;
State = 0;
Key = null;
NKey = 0;
SkipNext = 0;
#if !SQLITE_OMIT_INCRBLOB
IsIncrblob = false;
OverflowIDs = null;
#endif
PageID = 0;
}
public bool isIncrblobHandle; // True if this cursor is an incr. io handle
#endif
#region Methods
public void Clear()
{
pNext = null;
pPrev = null;
pKeyInfo = null;
pgnoRoot = 0;
cachedRowid = 0;
info = new CellInfo();
wrFlag = 0;
atLast = 0;
validNKey = false;
eState = 0;
pKey = null;
nKey = 0;
skipNext = 0;
#if !SQLITE_OMIT_INCRBLOB
isIncrblobHandle = false;
aOverflow = null;
#endif
iPage = 0;
}
public override bool UIKeyPressed(KeyInfo key)
{
if (key == null) throw new ArgumentNullException("key");
switch (key.VirtualKeyCode)
{
case KeyCode.F1:
if (key.Is())
{
Far.Api.ShowHelp(Far.Api.GetType().Assembly.Location, SettingsUI.HelpSettings, HelpOptions.None);
return true;
}
break;
case KeyCode.Delete:
case KeyCode.F8:
SetDefaults();
return true;
}
return base.UIKeyPressed(key);
}
// Methods
internal SvgElement(string prefix, string localname, string ns, SvgDocument doc)
: base(prefix, localname, ns, doc)
{
this.timeLineVisible = true;
KeyInfo[] infoArray1 = new KeyInfo[1] { new KeyInfo(0, 0) } ;
this.infoList = new ArrayList(infoArray1);
this.showParticular = false;
this.inKey = false;
this.animatelist = new SvgElementCollection();
this.svgAttributes = new Hashtable(0x10);
this.svgAnimAttributes = new Hashtable(0x10);
this.svgStyleAttributes = new Hashtable(0x10);
this.beforeChangeValueStr = string.Empty;
this.showchild = true;
this.pretime = -1;
this.AnimateNameValues = new Hashtable(0x10);
this.AttributePos = new Hashtable();
this.FormatOutXml = true;
this.UseElement = null;
this.CreateParse = true;
this.ownerDocument = doc;
this.FormatElement = false;
this.AllowRename = true;
}
public static string Sign(string xml, X509Certificate2 certificate)
{
if (xml == null) throw new ArgumentNullException("xml");
if (certificate == null) throw new ArgumentNullException("certificate");
if (!certificate.HasPrivateKey) throw new ArgumentException("certificate", "Certificate should have a private key");
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
doc.LoadXml(xml);
SignedXml signedXml = new SignedXml(doc);
signedXml.SigningKey = certificate.PrivateKey;
// Attach certificate KeyInfo
KeyInfoX509Data keyInfoData = new KeyInfoX509Data(certificate);
KeyInfo keyInfo = new KeyInfo();
keyInfo.AddClause(keyInfoData);
signedXml.KeyInfo = keyInfo;
// Attach transforms
var reference = new Reference("");
reference.AddTransform(new XmlDsigEnvelopedSignatureTransform(includeComments: false));
reference.AddTransform(new XmlDsigExcC14NTransform(includeComments: false));
signedXml.AddReference(reference);
// Compute signature
signedXml.ComputeSignature();
var signatureElement = signedXml.GetXml();
// Add signature to bundle
doc.DocumentElement.AppendChild(doc.ImportNode(signatureElement, true));
return doc.OuterXml;
}
// Inverse Utilities (name=>code)
static int FindCode(KeyInfo[] info, string key)
{
foreach(KeyInfo i in info) if(i.ki_name==key) return i.ki_key;
// not a registered key; might be generic code
if(!key.StartsWith("Unknown-")) return -1;
try
{
key=key.Substring(8);
return int.Parse(key);
}
catch
{
return -1;
}
}
public FirkinStream ReadValue(KeyInfo keyInfo)
{
return(new FirkinStream(_streamSyncRoot, _stream, (long)keyInfo.ValuePosition, (long)keyInfo.ValueSize));
}
public void GT()
{
var keyType = new KeyInfo(KeyDataType.IntKey, KeyType.ScalarIndex, "test", true);
//many in the middle
var idx1 = populate(1, 2, 3, 3, 3, 4, 5);
IList <CachedObject> result1 =
idx1.GetMany(MakeIntValue(3, keyType), QueryOperator.Gt).OrderBy(o => o.PrimaryKey).ToList();
Assert.AreEqual(result1.Count, 2);
Assert.AreEqual(result1[0].PrimaryKey, 5);
Assert.AreEqual(result1[1].PrimaryKey, 6);
var count = idx1.GetCount(MakeIntValue(3, keyType), QueryOperator.Gt);
Assert.AreEqual(count, 2);
//many at the end
var idx2 = populate(1, 2, 3, 3, 3);
result1 = idx2.GetMany(MakeIntValue(3, keyType), QueryOperator.Gt).OrderBy(o => o.PrimaryKey).ToList();
Assert.AreEqual(result1.Count, 0);
count = idx2.GetCount(MakeIntValue(3, keyType), QueryOperator.Gt);
Assert.AreEqual(count, 0);
//many at the beginning
var idx3 = populate(3, 3, 3, 4, 4, 80);
result1 = idx3.GetMany(MakeIntValue(3, keyType), QueryOperator.Gt).OrderBy(o => o.PrimaryKey).ToList();
Assert.AreEqual(result1.Count, 3);
Assert.AreEqual(result1[0].PrimaryKey, 3);
Assert.AreEqual(result1[1].PrimaryKey, 4);
Assert.AreEqual(result1[2].PrimaryKey, 5);
count = idx3.GetCount(MakeIntValue(3, keyType), QueryOperator.Gt);
Assert.AreEqual(count, 3);
//all equal
var idx4 = populate(3, 3, 3);
result1 = idx4.GetMany(MakeIntValue(3, keyType), QueryOperator.Gt).OrderBy(o => o.PrimaryKey).ToList();
Assert.AreEqual(result1.Count, 0);
count = idx4.GetCount(MakeIntValue(3, keyType), QueryOperator.Gt);
Assert.AreEqual(count, 0);
//one in the middle
var idx5 = populate(1, 3, 5, 7, 9, 111);
result1 = idx5.GetMany(MakeIntValue(7, keyType), QueryOperator.Gt).OrderBy(o => o.PrimaryKey).ToList();
Assert.AreEqual(result1.Count, 2);
Assert.AreEqual(result1[0].PrimaryKey, 4);
Assert.AreEqual(result1[1].PrimaryKey, 5);
count = idx5.GetCount(MakeIntValue(7, keyType), QueryOperator.Gt);
Assert.AreEqual(count, 2);
//value not found
result1 = idx5.GetMany(MakeIntValue(8, keyType), QueryOperator.Gt).OrderBy(o => o.PrimaryKey).ToList();
Assert.AreEqual(result1.Count, 2);
Assert.AreEqual(result1[0].PrimaryKey, 4);
Assert.AreEqual(result1[1].PrimaryKey, 5);
count = idx5.GetCount(MakeIntValue(8, keyType), QueryOperator.Gt);
Assert.AreEqual(count, 2);
}
private static void checkLS(IndexBase indexByValue)
{
var keyType = new KeyInfo(KeyDataType.IntKey, KeyType.ScalarIndex, "IndexKeyValue", true);
//non existent value in the middle
{
IList <CachedObject> result1 =
indexByValue.GetMany(MakeIntValue(12, keyType), QueryOperator.Lt)
.OrderBy(o => o.PrimaryKey)
.ToList();
Assert.AreEqual(result1.Count, 3);
Assert.AreEqual(result1[0].PrimaryKey.ToString(), "#1");
Assert.AreEqual(result1[1].PrimaryKey.ToString(), "#2");
Assert.AreEqual(result1[2].PrimaryKey.ToString(), "#3");
var count = indexByValue.GetCount(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(count, 3);
}
//existent value in the middle
{
IList <CachedObject> result1 =
indexByValue.GetMany(MakeIntValue(13, keyType), QueryOperator.Lt)
.OrderBy(o => o.PrimaryKey)
.ToList();
Assert.AreEqual(result1.Count, 3);
Assert.AreEqual(result1[2].PrimaryKey.ToString(), "#3");
var count = indexByValue.GetCount(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(count, 3);
}
//value < all
{
IList <CachedObject> result1 =
indexByValue.GetMany(MakeIntValue(0, keyType), QueryOperator.Lt).OrderBy(o => o.PrimaryKey)
.ToList();
Assert.AreEqual(result1.Count, 0);
var count = indexByValue.GetCount(MakeIntValue(0, keyType), QueryOperator.Lt);
Assert.AreEqual(count, 0);
}
//value > all
{
IList <CachedObject> result1 =
indexByValue.GetMany(MakeIntValue(99, keyType), QueryOperator.Lt)
.OrderBy(o => o.PrimaryKey)
.ToList();
Assert.AreEqual(result1.Count, 6);
var count = indexByValue.GetCount(MakeIntValue(99, keyType), QueryOperator.Lt);
Assert.AreEqual(count, 6);
}
//first value
{
IList <CachedObject> result1 =
indexByValue.GetMany(MakeIntValue(1, keyType), QueryOperator.Lt).OrderBy(o => o.PrimaryKey)
.ToList();
Assert.AreEqual(result1.Count, 0);
var count = indexByValue.GetCount(MakeIntValue(1, keyType), QueryOperator.Lt);
Assert.AreEqual(count, 0);
}
}
public TRetornoAssinatura AssinarNFe(string XMLString, string RefUri, X509Certificate2 _X509Cert)
/*
* Entradas:
* XMLString: string XML a ser assinada
* RefUri : Referência da URI a ser assinada ( infNFe, Cancelamento e inutilzacao)
* X509Cert : certificado digital a ser utilizado na assinatura digital
*
* Retornos:
* Assinar : 0 - Assinatura realizada com sucesso
* 1 - Erro: Problema ao acessar o certificado digital - %exceção%
* extinto* 2 - Problemas no certificado digital
* 3 - XML mal formado + exceção
* 4 - A tag de assinatura %RefUri% inexiste
* 5 - A tag de assinatura %RefUri% não é unica
* 6 - Erro Ao assinar o documento - ID deve ser string %RefUri(Atributo)%
* 7 - Erro: Ao assinar o documento - %exceção%
*
* XMLStringAssinado : string XML assinada
*
* XMLDocAssinado : XMLDocument do XML assinado
*/
{
var resultado = TRetornoAssinatura.Assinada;
msgResultado = "Assinatura realizada com sucesso";
try
{
// certificado ok
//_X509Cert = collection1[0];
// Cria um novo XML.
XmlDocument doc = new XmlDocument();
//XmlDocument doc2 = new XmlDocument();
//doc.PreserveWhitespace = false;
// carrega o conteudo XML passado
try
{
doc.LoadXml(XMLString);
// Verifica se a tag a ser assinada existe é única
int qtdeRefUri = doc.GetElementsByTagName(RefUri).Count;
if (qtdeRefUri == 0)
{
// a URI indicada não existe
resultado = TRetornoAssinatura.RefURiNaoExiste;//4;
msgResultado = "A tag de assinatura " + RefUri.Trim() + " inexiste";
}
// Exsiste mais de uma tag a ser assinada
else
{
if (qtdeRefUri > 1)
{
// existe mais de uma URI indicada
resultado = TRetornoAssinatura.RefURiNaoUnica; //5;
msgResultado = "A tag de assinatura " + RefUri.Trim() + " não é unica";
}
//else if (_listaNum.IndexOf(doc.GetElementsByTagName(RefUri).Item(0).Attributes.ToString().Substring(1,1))>0)
//{
// resultado = 6;
// msgResultado = "Erro: Ao assinar o documento - ID deve ser string (" + doc.GetElementsByTagName(RefUri).Item(0).Attributes + ")";
//}
else
{
try
{
// cria um objeto xml assinado
SignedXml signedXml = new SignedXml(doc);
// adiciona a chave do certificado
signedXml.SigningKey = _X509Cert.PrivateKey;
// Cria a referencia para assinatura
Reference reference = new Reference();
// pega o uri que deve ser assinada
XmlAttributeCollection _Uri = doc.GetElementsByTagName(RefUri).Item(0).Attributes;
foreach (XmlAttribute _atributo in _Uri)
{
if (_atributo.Name == "Id")
{
reference.Uri = "#" + _atributo.InnerText;
}
}
#region calculo assinatura NFe
// adiciona um XmlDsigEnvelopedSignatureTransform para a assinatura
XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(env);
XmlDsigC14NTransform c14 = new XmlDsigC14NTransform();
reference.AddTransform(c14);
// adiciona a referencia no xml assinado
signedXml.AddReference(reference);
// Cria a chave
KeyInfo keyInfo = new KeyInfo();
// carrega o certificado em um keyinfox509
// e adiciona ao keyinfo
keyInfo.AddClause(new KeyInfoX509Data(_X509Cert));
// adiciona o keyinfo ao xml assinado
signedXml.KeyInfo = keyInfo;
signedXml.ComputeSignature();
#endregion
// busca a representacao XML da assinatura e salva no XML
XmlElement xmlDigitalSignature = signedXml.GetXml();
// adiciona a assinatura no documento
doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, true));
//salva o documento assinado
XMLDoc = new XmlDocument();
//XMLDoc.PreserveWhitespace = false;
XMLDoc = doc;
}
catch (Exception caught)
{
resultado = TRetornoAssinatura.ErroAoAssinarDocumento;// 7;
msgResultado = "Erro: Ao assinar o documento - " + caught.Message;
}
}
}
}
catch (Exception caught)
{
resultado = TRetornoAssinatura.XMLMalFormado;// 3;
msgResultado = "Erro: XML mal formado - " + caught.Message;
}
}
catch (Exception caught)
{
resultado = TRetornoAssinatura.ProblemaAoAcessarCertificado;// 1;
msgResultado = "Erro: Problema ao acessar o certificado digital" + caught.Message;
}
return(resultado);
}
// <Snippet2>
// Sign an XML file and save the signature in a new file.
public static void SignXmlFile(string FileName, string SignedFileName, DSA DSAKey)
{
// Create a new XML document.
XmlDocument doc = new XmlDocument();
// Format the document to ignore white spaces.
doc.PreserveWhitespace = false;
// Load the passed XML file using it's name.
doc.Load(new XmlTextReader(FileName));
// Create a SignedXml object.
SignedXml signedXml = new SignedXml(doc);
// Add the DSA key to the SignedXml document.
signedXml.SigningKey = DSAKey;
// Create a reference to be signed.
Reference reference = new Reference();
reference.Uri = "";
// Add a transformation to the reference.
Transform trns = new XmlDsigC14NTransform();
reference.AddTransform(trns);
// Add an enveloped transformation to the reference.
XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(env);
// Add the reference to the SignedXml object.
signedXml.AddReference(reference);
// Add a DSAKeyValue to the KeyInfo (optional; helps recipient find key to validate).
KeyInfo keyInfo = new KeyInfo();
keyInfo.AddClause(new DSAKeyValue((DSA)DSAKey));
signedXml.KeyInfo = keyInfo;
// Compute the signature.
signedXml.ComputeSignature();
// Get the XML representation of the signature and save
// it to an XmlElement object.
XmlElement xmlDigitalSignature = signedXml.GetXml();
// Append the element to the XML document.
doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, true));
if (doc.FirstChild is XmlDeclaration)
{
doc.RemoveChild(doc.FirstChild);
}
// Save the signed XML document to a file specified
// using the passed string.
XmlTextWriter xmltw = new XmlTextWriter(SignedFileName, new UTF8Encoding(false));
doc.WriteTo(xmltw);
xmltw.Close();
}
/// <summary>
/// Sign an xml element with the supplied cert.
/// </summary>
/// <param name="xmlElement">xmlElement to be signed. The signature is
/// added as a node in the document, right after the Issuer node.</param>
/// <param name="cert">Certificate to use when signing.</param>
/// <param name="includeKeyInfo">Include public key in signed output.</param>
/// <param name="signingAlgorithm">The signing algorithm to use.</param>
public static void Sign(
this XmlElement xmlElement,
X509Certificate2 cert,
bool includeKeyInfo,
string signingAlgorithm)
{
if (xmlElement == null)
{
throw new ArgumentNullException(nameof(xmlElement));
}
if (cert == null)
{
throw new ArgumentNullException(nameof(cert));
}
var signedXml = new SignedXmlWithIdFix(xmlElement.OwnerDocument);
// The transform XmlDsigExcC14NTransform and canonicalization method XmlDsigExcC14NTransformUrl is important for partially signed XML files
// see: http://msdn.microsoft.com/en-us/library/system.security.cryptography.xml.signedxml.xmldsigexcc14ntransformurl(v=vs.110).aspx
// The reference URI has to be set correctly to avoid assertion injections
// For both, the ID/Reference and the Transform/Canonicalization see as well:
// https://www.oasis-open.org/committees/download.php/35711/sstc-saml-core-errata-2.0-wd-06-diff.pdf section 5.4.2 and 5.4.3
signedXml.SigningKey = EnvironmentHelpers.IsNetCore
? cert.PrivateKey
: ((RSACryptoServiceProvider)cert.PrivateKey)
.GetSha256EnabledRSACryptoServiceProvider();
signedXml.SignedInfo.CanonicalizationMethod = SignedXml.XmlDsigExcC14NTransformUrl;
signedXml.SignedInfo.SignatureMethod = signingAlgorithm;
// We need a document unique ID on the element to sign it -- make one up if it's missing
string id = xmlElement.GetAttribute("ID");
if (String.IsNullOrEmpty(id))
{
id = "_" + Guid.NewGuid().ToString("N");
xmlElement.SetAttribute("ID", id);
}
var reference = new Reference
{
Uri = "#" + id,
DigestMethod = GetCorrespondingDigestAlgorithm(signingAlgorithm)
};
reference.AddTransform(new XmlDsigEnvelopedSignatureTransform());
reference.AddTransform(new XmlDsigExcC14NTransform());
signedXml.AddReference(reference);
signedXml.ComputeSignature();
if (includeKeyInfo)
{
var keyInfo = new KeyInfo();
keyInfo.AddClause(new KeyInfoX509Data(cert));
signedXml.KeyInfo = keyInfo;
}
xmlElement.InsertAfter(
xmlElement.OwnerDocument.ImportNode(signedXml.GetXml(), true),
xmlElement["Issuer", Saml2Namespaces.Saml2Name]);
}
// Sign an XML file and save the signature in a new file.
public static void SignXmlFile(string FileName, string SignedFileName, RSA Key, string[] ElementsToSign)
{
// Check the arguments.
if (FileName == null)
{
throw new ArgumentNullException("FileName");
}
if (SignedFileName == null)
{
throw new ArgumentNullException("SignedFileName");
}
if (Key == null)
{
throw new ArgumentNullException("Key");
}
if (ElementsToSign == null)
{
throw new ArgumentNullException("ElementsToSign");
}
// Create a new XML document.
XmlDocument doc = new XmlDocument();
// Format the document to ignore white spaces.
doc.PreserveWhitespace = false;
// Load the passed XML file using it's name.
doc.Load(new XmlTextReader(FileName));
// Create a SignedXml object.
SignedXml signedXml = new SignedXml(doc);
// Add the key to the SignedXml document.
signedXml.SigningKey = Key;
// Loop through each passed element to sign
// and create a reference.
foreach (string s in ElementsToSign)
{
// Create a reference to be signed.
Reference reference = new Reference();
reference.Uri = s;
// Add an enveloped transformation to the reference.
XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(env);
// Add the reference to the SignedXml object.
signedXml.AddReference(reference);
}
// Add an RSAKeyValue KeyInfo (optional; helps recipient find key to validate).
KeyInfo keyInfo = new KeyInfo();
keyInfo.AddClause(new RSAKeyValue((RSA)Key));
signedXml.KeyInfo = keyInfo;
// Compute the signature.
signedXml.ComputeSignature();
// Get the XML representation of the signature and save
// it to an XmlElement object.
XmlElement xmlDigitalSignature = signedXml.GetXml();
// Append the element to the XML document.
doc.DocumentElement.AppendChild(doc.ImportNode(xmlDigitalSignature, true));
if (doc.FirstChild is XmlDeclaration)
{
doc.RemoveChild(doc.FirstChild);
}
// Save the signed XML document to a file specified
// using the passed string.
XmlTextWriter xmltw = new XmlTextWriter(SignedFileName, new UTF8Encoding(false));
doc.WriteTo(xmltw);
xmltw.Close();
}
public static void Generate(XmlElement xmlElement, AsymmetricAlgorithm signingKey, KeyInfo keyInfo)
{
SAMLMetadataSignature.Generate(xmlElement, signingKey, keyInfo, "#default md saml ds xs xsi", (string)null, (string)null);
}
/// <summary>
/// An example on how to decrypt an encrypted assertion.
/// </summary>
/// <param name="file">The file.</param>
public static void DecryptAssertion(string file)
{
var doc = new XmlDocument();
doc.Load(file);
var encryptedDataElement = GetElement(Schema.XEnc.EncryptedData.ElementName, Saml20Constants.Xenc, doc);
var encryptedData = new EncryptedData();
encryptedData.LoadXml(encryptedDataElement);
var nodelist = doc.GetElementsByTagName(Schema.XmlDSig.KeyInfo.ElementName, Saml20Constants.Xmldsig);
Assert.True(nodelist.Count > 0);
var key = new KeyInfo();
key.LoadXml((XmlElement)nodelist[0]);
// Review: Is it possible to figure out which certificate to load based on the Token?
/*
* Comment:
* It would be possible to provide a key/certificate identifier in the EncryptedKey element, which contains the "recipient" attribute.
* The implementation (Safewhere.Tokens.Saml20.Saml20EncryptedAssertion) currently just expects an appropriate asymmetric key to be provided,
* and is not not concerned about its origin.
* If the need arises, we can easily extend the Saml20EncryptedAssertion class with a property that allows extraction key info, eg. the "recipient"
* attribute.
*/
var cert = Certificates.InMemoryResourceUtility.GetInMemoryCertificate("sts_dev_certificate.pfx", "test1234");
// ms-help://MS.MSDNQTR.v80.en/MS.MSDN.v80/MS.NETDEVFX.v20.en/CPref18/html/T_System_Security_Cryptography_Xml_KeyInfoClause_DerivedTypes.htm
// Look through the list of KeyInfo elements to find the encrypted key.
SymmetricAlgorithm symmetricKey = null;
foreach (KeyInfoClause keyInfoClause in key)
{
if (keyInfoClause is KeyInfoEncryptedKey)
{
var keyInfoEncryptedKey = (KeyInfoEncryptedKey)keyInfoClause;
var encryptedKey = keyInfoEncryptedKey.EncryptedKey;
symmetricKey = new RijndaelManaged
{
Key = EncryptedXml.DecryptKey(encryptedKey.CipherData.CipherValue, (RSA)cert.PrivateKey, false)
};
}
}
// Explode if we didn't manage to find a viable key.
Assert.NotNull(symmetricKey);
var encryptedXml = new EncryptedXml();
var plaintext = encryptedXml.DecryptData(encryptedData, symmetricKey);
var assertion = new XmlDocument();
assertion.Load(new StringReader(System.Text.Encoding.UTF8.GetString(plaintext)));
// A very simple test to ensure that there is indeed an assertion in the plaintext.
Assert.Equal(Assertion.ElementName, assertion.DocumentElement.LocalName);
Assert.Equal(Saml20Constants.Assertion, assertion.DocumentElement.NamespaceURI);
// At this point, assertion will contain a decrypted assertion.
}
public static void Generate(XmlElement xmlElement, AsymmetricAlgorithm signingKey, KeyInfo keyInfo, string inclusiveNamespacesPrefixList, string digestMethod, string signatureMethod)
{
if (inclusiveNamespacesPrefixList == null)
{
inclusiveNamespacesPrefixList = "#default md saml ds xs xsi";
}
XmlElement xmlSignature = XmlSignature.Generate(xmlElement, SAMLMetadataSignature.GetID(xmlElement), signingKey, keyInfo, (SignedXml) new SignedMetadata(xmlElement), inclusiveNamespacesPrefixList, digestMethod, signatureMethod);
SAMLMetadataSignature.AddSignature(xmlElement, xmlSignature);
}
public static bool Verify(XmlElement xmlElement, KeyInfo keyInfo)
{
return(XmlSignature.Verify(xmlElement, keyInfo, (SignedXml) new SignedMetadata(xmlElement)));
}
public void SetUp()
{
info = new KeyInfo();
}
static void sqlite3VdbeChangeP4( Vdbe p, int addr, union_p4 _p4, int n )
{
Op pOp;
sqlite3 db;
Debug.Assert( p != null );
db = p.db;
Debug.Assert( p.magic == VDBE_MAGIC_INIT );
if ( p.aOp == null /*|| db.mallocFailed != 0 */)
{
if ( n != P4_KEYINFO && n != P4_VTAB )
{
freeP4( db, n, _p4 );
}
return;
}
Debug.Assert( p.nOp > 0 );
Debug.Assert( addr < p.nOp );
if ( addr < 0 )
{
addr = p.nOp - 1;
}
pOp = p.aOp[addr];
freeP4( db, pOp.p4type, pOp.p4.p );
pOp.p4.p = null;
if ( n == P4_INT32 )
{
/* Note: this cast is safe, because the origin data point was an int
** that was cast to a (string ). */
pOp.p4.i = _p4.i; // SQLITE_PTR_TO_INT(zP4);
pOp.p4type = P4_INT32;
}
else if ( n == P4_INT64 )
{
pOp.p4.pI64 = _p4.pI64;
pOp.p4type = n;
}
else if ( n == P4_REAL )
{
pOp.p4.pReal = _p4.pReal;
pOp.p4type = n;
}
else if ( _p4 == null )
{
pOp.p4.p = null;
pOp.p4type = P4_NOTUSED;
}
else if ( n == P4_KEYINFO )
{
KeyInfo pKeyInfo;
int nField, nByte;
nField = _p4.pKeyInfo.nField;
//nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo.aColl[0]) + nField;
pKeyInfo = new KeyInfo();//sqlite3DbMallocRaw(0, nByte);
pOp.p4.pKeyInfo = pKeyInfo;
if ( pKeyInfo != null )
{
//u8 *aSortOrder;
// memcpy((char)pKeyInfo, zP4, nByte - nField);
//aSortOrder = pKeyInfo.aSortOrder;
//if( aSortOrder ){
// pKeyInfo.aSortOrder = (unsigned char)&pKeyInfo.aColl[nField];
// memcpy(pKeyInfo.aSortOrder, aSortOrder, nField);
//}
pKeyInfo = _p4.pKeyInfo.Copy();
pOp.p4type = P4_KEYINFO;
}
else
{
//p.db.mallocFailed = 1;
pOp.p4type = P4_NOTUSED;
}
pOp.p4.pKeyInfo = _p4.pKeyInfo;
pOp.p4type = P4_KEYINFO;
}
else if ( n == P4_KEYINFO_HANDOFF || n == P4_KEYINFO_STATIC )
{
pOp.p4.pKeyInfo = _p4.pKeyInfo;
pOp.p4type = P4_KEYINFO;
}
else if ( n == P4_FUNCDEF )
{
pOp.p4.pFunc = _p4.pFunc;
pOp.p4type = P4_FUNCDEF;
}
else if ( n == P4_COLLSEQ )
{
pOp.p4.pColl = _p4.pColl;
pOp.p4type = P4_COLLSEQ;
}
else if ( n == P4_DYNAMIC || n == P4_STATIC || n == P4_MPRINTF )
{
pOp.p4.z = _p4.z;
pOp.p4type = P4_DYNAMIC;
}
else if ( n == P4_MEM )
{
pOp.p4.pMem = _p4.pMem;
pOp.p4type = P4_MEM;
}
else if ( n == P4_INTARRAY )
{
pOp.p4.ai = _p4.ai;
pOp.p4type = P4_INTARRAY;
}
else if ( n == P4_SUBPROGRAM )
{
pOp.p4.pProgram = _p4.pProgram;
pOp.p4type = P4_SUBPROGRAM;
}
else if ( n == P4_VTAB )
{
pOp.p4.pVtab = _p4.pVtab;
pOp.p4type = P4_VTAB;
sqlite3VtabLock( _p4.pVtab );
Debug.Assert( ( _p4.pVtab ).db == p.db );
}
else if ( n < 0 )
{
pOp.p4.p = _p4.p;
pOp.p4type = n;
}
else
{
//if (n == 0) n = n = sqlite3Strlen30(zP4);
pOp.p4.z = _p4.z;// sqlite3DbStrNDup(p.db, zP4, n);
pOp.p4type = P4_DYNAMIC;
}
}
public Stream Decrypt(EncryptionMethod encryptionMethod, KeyInfo keyInfo, Stream toDecrypt)
{
Assert.NotNull(encryptionMethod);
Assert.NotNull(keyInfo);
Assert.NotNull(toDecrypt);
Assert.True(encryptionMethod.KeyAlgorithm == EncryptedXml.XmlEncAES128Url ||
encryptionMethod.KeyAlgorithm == EncryptedXml.XmlEncAES192Url ||
encryptionMethod.KeyAlgorithm == EncryptedXml.XmlEncAES256Url);
Assert.Equal(keyInfo.Count, 1);
byte[] decryptedKey = null;
foreach (KeyInfoClause clause in keyInfo)
{
if (clause is KeyInfoEncryptedKey)
{
KeyInfoEncryptedKey encryptedKeyInfo = clause as KeyInfoEncryptedKey;
EncryptedKey encryptedKey = encryptedKeyInfo.EncryptedKey;
Assert.Equal(encryptedKey.EncryptionMethod.KeyAlgorithm, EncryptedXml.XmlEncRSAOAEPUrl);
Assert.Equal(encryptedKey.KeyInfo.Count, 1);
Assert.NotEqual(_asymmetricKeys.Count, 0);
RSAParameters rsaParams = new RSAParameters();
RSAParameters rsaInputParams = new RSAParameters();
foreach (KeyInfoClause rsa in encryptedKey.KeyInfo)
{
if (rsa is RSAKeyValue)
{
rsaParams = (rsa as RSAKeyValue).Key.ExportParameters(false);
break;
}
else
{
Assert.True(false, "Invalid License - MalformedKeyInfoClause");
}
}
bool keyMismatch = true;
foreach (AsymmetricAlgorithm key in _asymmetricKeys)
{
RSA rsaKey = key as RSA;
Assert.NotNull(rsaKey);
rsaInputParams = rsaKey.ExportParameters(false);
if (!PublicKeysEqual(rsaParams, rsaInputParams))
{
continue;
}
keyMismatch = false;
// Decrypt session key
byte[] encryptedKeyValue = encryptedKey.CipherData.CipherValue;
if (encryptedKeyValue == null)
{
throw new CryptographicException("MissingKeyCipher");
}
decryptedKey = EncryptedXml.DecryptKey(encryptedKeyValue,
rsaKey, true);
break;
}
if (keyMismatch)
{
throw new Exception("Invalid License - AsymmetricKeyMismatch");
}
}
else if (clause is KeyInfoName)
{
Assert.True(false, "This test should not have KeyInfoName clauses");
}
else
{
throw new CryptographicException("MalformedKeyInfoClause");
}
break;
}
if (decryptedKey == null)
{
throw new CryptographicException("KeyDecryptionFailure");
}
using (Aes aes = Aes.Create())
{
aes.Key = decryptedKey;
aes.Padding = PaddingMode.PKCS7;
aes.Mode = CipherMode.CBC;
return(DecryptStream(toDecrypt, aes));
}
}
/*
** Given the nKey-byte encoding of a record in pKey[], parse the
** record into a UnpackedRecord structure. Return a pointer to
** that structure.
**
** The calling function might provide szSpace bytes of memory
** space at pSpace. This space can be used to hold the returned
** VDbeParsedRecord structure if it is large enough. If it is
** not big enough, space is obtained from sqlite3Malloc().
**
** The returned structure should be closed by a call to
** sqlite3VdbeDeleteUnpackedRecord().
*/
static UnpackedRecord sqlite3VdbeRecordUnpack(
KeyInfo pKeyInfo, /* Information about the record format */
int nKey, /* Size of the binary record */
byte[] pKey, /* The binary record */
UnpackedRecord pSpace, // char *pSpace, /* Unaligned space available to hold the object */
int szSpace /* Size of pSpace[] in bytes */
)
{
byte[] aKey = pKey;
UnpackedRecord p; /* The unpacked record that we will return */
int nByte; /* Memory space needed to hold p, in bytes */
int d;
u32 idx;
int u; /* Unsigned loop counter */
int szHdr = 0;
Mem pMem;
int nOff; /* Increase pSpace by this much to 8-byte align it */
/*
** We want to shift the pointer pSpace up such that it is 8-byte aligned.
** Thus, we need to calculate a value, nOff, between 0 and 7, to shift
** it by. If pSpace is already 8-byte aligned, nOff should be zero.
*/
//nOff = ( 8 - ( SQLITE_PTR_TO_INT( pSpace ) & 7 ) ) & 7;
//pSpace += nOff;
//szSpace -= nOff;
//nByte = ROUND8( sizeof( UnpackedRecord ) ) + sizeof( Mem ) * ( pKeyInfo->nField + 1 );
//if ( nByte > szSpace)
//{
//var p = new UnpackedRecord();//sqlite3DbMallocRaw(pKeyInfo.db, nByte);
// if ( p == null ) return null;
// p.flags = UNPACKED_NEED_FREE | UNPACKED_NEED_DESTROY;
//}
//else
{
p = pSpace;//(UnpackedRecord)pSpace;
p.flags = UNPACKED_NEED_DESTROY;
}
p.pKeyInfo = pKeyInfo;
p.nField = (u16)( pKeyInfo.nField + 1 );
//p->aMem = pMem = (Mem)&( (char)p )[ROUND8( sizeof( UnpackedRecord ) )];
//Debug.Assert( EIGHT_BYTE_ALIGNMENT( pMem ) );
p.aMem = new Mem[p.nField + 1];
idx = (u32)getVarint32( aKey, 0, out szHdr );// GetVarint( aKey, szHdr );
d = (int)szHdr;
u = 0;
while ( idx < (int)szHdr && u < p.nField && d <= nKey )
{
p.aMem[u] = sqlite3Malloc( p.aMem[u] );
pMem = p.aMem[u];
u32 serial_type = 0;
idx += (u32)getVarint32( aKey, idx, out serial_type );// GetVarint( aKey + idx, serial_type );
pMem.enc = pKeyInfo.enc;
pMem.db = pKeyInfo.db;
/* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
//pMem.zMalloc = null;
d += (int)sqlite3VdbeSerialGet( aKey, d, serial_type, pMem );
//pMem++;
u++;
}
Debug.Assert( u <= pKeyInfo.nField + 1 );
p.nField = (u16)u;
return p;// (void)p;
}
/// <summary>
/// Realiza la contrafirma de la firma actual
/// </summary>
/// <param name="sigDocument"></param>
/// <param name="parameters"></param>
public SignatureDocument CounterSign(SignatureDocument sigDocument, SignatureParameters parameters)
{
if (parameters.Signer == null)
{
throw new Exception("Es necesario un certificado válido para la firma.");
}
SignatureDocument.CheckSignatureDocument(sigDocument);
SignatureDocument counterSigDocument = new SignatureDocument();
counterSigDocument.Document = (XmlDocument)sigDocument.Document.Clone();
counterSigDocument.Document.PreserveWhitespace = true;
XadesSignedXml counterSignature = new XadesSignedXml(counterSigDocument.Document);
SetSignatureId(counterSignature);
counterSignature.SigningKey = parameters.Signer.SigningKey;
_refContent = new Reference();
_refContent.Uri = "#" + sigDocument.XadesSignature.SignatureValueId;
_refContent.Id = "Reference-" + Guid.NewGuid().ToString();
_refContent.Type = "http://uri.etsi.org/01903#CountersignedSignature";
_refContent.AddTransform(new XmlDsigC14NTransform());
counterSignature.AddReference(_refContent);
_mimeType = "text/xml";
_encoding = "UTF-8";
KeyInfo keyInfo = new KeyInfo();
keyInfo.Id = "KeyInfoId-" + counterSignature.Signature.Id;
keyInfo.AddClause(new KeyInfoX509Data((X509Certificate)parameters.Signer.Certificate));
keyInfo.AddClause(new RSAKeyValue((RSA)parameters.Signer.SigningKey));
counterSignature.KeyInfo = keyInfo;
Reference referenceKeyInfo = new Reference();
referenceKeyInfo.Id = "ReferenceKeyInfo-" + counterSignature.Signature.Id;
referenceKeyInfo.Uri = "#KeyInfoId-" + counterSignature.Signature.Id;
counterSignature.AddReference(referenceKeyInfo);
XadesObject counterSignatureXadesObject = new XadesObject();
counterSignatureXadesObject.Id = "CounterSignatureXadesObject-" + Guid.NewGuid().ToString();
counterSignatureXadesObject.QualifyingProperties.Target = "#" + counterSignature.Signature.Id;
counterSignatureXadesObject.QualifyingProperties.SignedProperties.Id = "SignedProperties-" + counterSignature.Signature.Id;
AddSignatureProperties(counterSigDocument, counterSignatureXadesObject.QualifyingProperties.SignedProperties.SignedSignatureProperties,
counterSignatureXadesObject.QualifyingProperties.SignedProperties.SignedDataObjectProperties,
counterSignatureXadesObject.QualifyingProperties.UnsignedProperties.UnsignedSignatureProperties, parameters);
counterSignature.AddXadesObject(counterSignatureXadesObject);
foreach (Reference signReference in counterSignature.SignedInfo.References)
{
signReference.DigestMethod = parameters.DigestMethod.URI;
}
counterSignature.SignedInfo.SignatureMethod = parameters.SignatureMethod.URI;
counterSignature.AddXadesNamespace = true;
counterSignature.ComputeSignature();
counterSigDocument.XadesSignature = new XadesSignedXml(counterSigDocument.Document);
counterSigDocument.XadesSignature.LoadXml(sigDocument.XadesSignature.GetXml());
UnsignedProperties unsignedProperties = counterSigDocument.XadesSignature.UnsignedProperties;
unsignedProperties.UnsignedSignatureProperties.CounterSignatureCollection.Add(counterSignature);
counterSigDocument.XadesSignature.UnsignedProperties = unsignedProperties;
counterSigDocument.UpdateDocument();
return(counterSigDocument);
}
static DCinemaSecurityMessageType SignETM(DCinemaSecurityMessageType extraTheatreMessage, X509Certificate2 x509Certificate2)
{
SignedXml signedXml = null;
try
{
signedXml = new SignedXml();
signedXml.SigningKey = x509Certificate2.PrivateKey;
//signedXml.SignedInfo.SignatureMethod = "http://www.w3.org/ 2001/04/xmldsig-more#rsasha256";
//signedXml.SignedInfo.SignatureMethod = "http://www.w3.org/2001/04/xmlenc#sha256";
signedXml.SignedInfo.CanonicalizationMethod = "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments";
StringWriter stringWriter = new StringWriter();
XmlSerializer xmlSerializer = new XmlSerializer(typeof(DCinemaSecurityMessageType));
xmlSerializer.Serialize(stringWriter, extraTheatreMessage);
string serializedXML = stringWriter.ToString();
#region Build the AuthenticatedPublic DataObject & Reference
string xmlAuthenticatedPublic = GetCleanElement(serializedXML, "AuthenticatedPublic");
XmlDocument docAuthenticatedPublic = new XmlDocument();
docAuthenticatedPublic.LoadXml(xmlAuthenticatedPublic.ToString());
//XmlAttribute attrAuthenticatedPublic = docAuthenticatedPublic.CreateAttribute("xmlns");
//attrAuthenticatedPublic.Value = "http://www.smpte-ra.org/schemas/430-3/2006/ETM";
//docAuthenticatedPublic.DocumentElement.Attributes.Append(attrAuthenticatedPublic);
DataObject dataObjectAuthenticatedPublic = new DataObject("AuthenticatedPublic", "", "", docAuthenticatedPublic.DocumentElement);
//DataObject dataObjectAuthenticatedPublic = new DataObject();
dataObjectAuthenticatedPublic.Data = docAuthenticatedPublic.ChildNodes;
dataObjectAuthenticatedPublic.Id = "AuthenticatedPublic";
signedXml.AddObject(dataObjectAuthenticatedPublic);
Reference referenceAuthenticatedPublic = new Reference();
referenceAuthenticatedPublic.Uri = "#AuthenticatedPublic";
referenceAuthenticatedPublic.DigestMethod = "http://www.w3.org/2001/04/xmlenc#sha256";
signedXml.AddReference(referenceAuthenticatedPublic);
#endregion
#region Build the AuthenticatedPublic DataObject & Reference
string xmlAuthenticatedPrivate = GetCleanElement(serializedXML, "AuthenticatedPrivate");
XmlDocument docAuthenticatedPrivate = new XmlDocument();
docAuthenticatedPrivate.LoadXml(xmlAuthenticatedPrivate.ToString());
//XmlAttribute attrAuthenticatedPrivate = docAuthenticatedPrivate.CreateAttribute("xmlns");
//attrAuthenticatedPrivate.Value = "http://www.smpte-ra.org/schemas/430-3/2006/FLM";
//docAuthenticatedPrivate.DocumentElement.Attributes.Append(attrAuthenticatedPrivate);
DataObject dataObjectAuthenticatedPrivate = new DataObject("AuthenticatedPrivate", "", "", docAuthenticatedPrivate.DocumentElement);
//DataObject dataObjectAuthenticatedPrivate = new DataObject("AuthenticatedPrivate", "", "", docAuthenticatedPrivate.DocumentElement);
//dataObjectAuthenticatedPrivate.Data = docAuthenticatedPrivate.ChildNodes;
//dataObjectAuthenticatedPrivate.Id = "AuthenticatedPrivate";
signedXml.AddObject(dataObjectAuthenticatedPrivate);
Reference referenceAuthenticatedPrivate = new Reference();
referenceAuthenticatedPrivate.Uri = "#AuthenticatedPrivate";
referenceAuthenticatedPrivate.DigestMethod = "http://www.w3.org/2001/04/xmlenc#sha256";
// Add the reference to the message.
signedXml.AddReference(referenceAuthenticatedPrivate);
#endregion
// Add a KeyInfo.
KeyInfo keyInfo = new KeyInfo();
keyInfo.AddClause(new KeyInfoX509Data(x509Certificate2, X509IncludeOption.WholeChain));
signedXml.KeyInfo = keyInfo;
// Compute the signature.
signedXml.ComputeSignature();
XmlElement singedElement = signedXml.GetXml();
XmlSerializer signedSerializer = new XmlSerializer(singedElement.GetType());
StreamWriter signedWriter = new StreamWriter(@"\SOURCE_SMPTE\Output\signedSerializer.Test.xml");
signedSerializer.Serialize(signedWriter, singedElement);
signedWriter.Close();
}
catch (CryptographicException e)
{
Console.WriteLine(e.Message);
}
extraTheatreMessage.Signature = signedXml.Signature.GetXml();
return(extraTheatreMessage);
}
public async Task CreateAsync(KeyInfo key)
{
Ensure.NotNull(key, nameof(key));
await db.Keys.InsertAsync(key);
}
public void ExtremeCases()
{
//void index
var keyType = new KeyInfo(KeyDataType.IntKey, KeyType.ScalarIndex, "test", true);
IndexBase index = populate();
var result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Le);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType));
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Gt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Ge);
Assert.AreEqual(result.Count, 0);
//one element index, value not found
index = populate(15);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Le);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType));
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Gt);
Assert.AreEqual(result.Count, 1);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Ge);
Assert.AreEqual(result.Count, 1);
//one element index, value found
index = populate(12);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Le);
Assert.AreEqual(result.Count, 1);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType));
Assert.AreEqual(result.Count, 1);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Gt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Ge);
Assert.AreEqual(result.Count, 1);
//two element index (different values)
index = populate(12, 15);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Le);
Assert.AreEqual(result.Count, 1);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType));
Assert.AreEqual(result.Count, 1);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Gt);
Assert.AreEqual(result.Count, 1);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Ge);
Assert.AreEqual(result.Count, 2);
//two element index (same value)
index = populate(12, 12);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Le);
Assert.AreEqual(result.Count, 2);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType));
Assert.AreEqual(result.Count, 2);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Gt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Ge);
Assert.AreEqual(result.Count, 2);
//three element index (same value ==)
index = populate(12, 12, 12);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Le);
Assert.AreEqual(result.Count, 3);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType));
Assert.AreEqual(result.Count, 3);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Gt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Ge);
Assert.AreEqual(result.Count, 3);
//three element index (same value !=)
index = populate(15, 15, 15);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Le);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType));
Assert.AreEqual(result.Count, 0);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Gt);
Assert.AreEqual(result.Count, 3);
result = index.GetMany(MakeIntValue(12, keyType), QueryOperator.Ge);
Assert.AreEqual(result.Count, 3);
}
public Stream Decrypt(EncryptionMethod encryptionMethod, KeyInfo keyInfo, Stream toDecrypt)
{
Assert.NotNull(encryptionMethod);
Assert.NotNull(keyInfo);
Assert.NotNull(toDecrypt);
Assert.True(encryptionMethod.KeyAlgorithm == NS.XmlEncAES128Url ||
encryptionMethod.KeyAlgorithm == NS.XmlEncAES192Url ||
encryptionMethod.KeyAlgorithm == NS.XmlEncAES256Url);
Assert.Equal(keyInfo.Count, 1);
byte[] decryptedKey = null;
foreach (KeyInfoClause clause in keyInfo)
{
if (clause is KeyInfoEncryptedKey)
{
KeyInfoEncryptedKey encryptedKeyInfo = clause as KeyInfoEncryptedKey;
EncryptedKey encryptedKey = encryptedKeyInfo.GetEncryptedKey();
Assert.Equal(encryptedKey.EncryptionMethod.KeyAlgorithm, NS.XmlEncRSAOAEPUrl);
Assert.Equal(encryptedKey.KeyInfo.Count, 1);
Assert.NotEqual(_asymmetricKeys.Count, 0);
RsaKeyParameters rsaParams = null;
RsaKeyParameters rsaInputParams = null;
foreach (KeyInfoClause rsa in encryptedKey.KeyInfo)
{
if (rsa is RsaKeyValue)
{
rsaParams = (rsa as RsaKeyValue).GetKey();
break;
}
else
{
Assert.True(false, "Invalid License - MalformedKeyInfoClause");
}
}
bool keyMismatch = true;
foreach (AsymmetricCipherKeyPair key in _asymmetricKeys)
{
RsaKeyParameters rsaKey = key.Private as RsaKeyParameters;
Assert.NotNull(rsaKey);
rsaInputParams = key.Public as RsaKeyParameters;
Assert.NotNull(rsaInputParams);
if (!PublicKeysEqual(rsaParams, rsaInputParams))
{
continue;
}
keyMismatch = false;
byte[] encryptedKeyValue = encryptedKey.CipherData.CipherValue;
if (encryptedKeyValue == null)
{
throw new System.Security.Cryptography.CryptographicException("MissingKeyCipher");
}
decryptedKey = XmlDecryption.DecryptKey(encryptedKeyValue,
rsaKey, true);
break;
}
if (keyMismatch)
{
throw new Exception("Invalid License - AsymmetricKeyMismatch");
}
}
else if (clause is KeyInfoName)
{
Assert.True(false, "This test should not have KeyInfoName clauses");
}
else
{
throw new System.Security.Cryptography.CryptographicException("MalformedKeyInfoClause");
}
break;
}
if (decryptedKey == null)
{
throw new System.Security.Cryptography.CryptographicException("KeyDecryptionFailure");
}
return(DecryptStream(toDecrypt, new KeyParameter(decryptedKey), "AES/CBC/PKCS7"));
}
public void Lesser()
{
//register the type to get a valid TypeDescription
//the type description is used to create CachedObjects from objects of the registered type
var typeDescription = ClientSideTypeDescription.RegisterType(typeof(CacheableTypeOk));
KeyInfo valueKey = null;
foreach (var keyInfo in typeDescription.IndexFields)
{
if (keyInfo.Name == "IndexKeyValue")
{
valueKey = keyInfo.AsKeyInfo;
}
}
Assert.IsNotNull(valueKey);
//fill in order
{
var indexByValue = new OrderedIndex(valueKey);
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(1, 101, "A", DateTime.Now, 1)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(2, 102, "A", DateTime.Now, 4)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(3, 103, "A", DateTime.Now, 6)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(4, 104, "A", DateTime.Now, 13)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(5, 105, "A", DateTime.Now, 14)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(6, 106, "A", DateTime.Now, 80)));
checkLE(indexByValue);
checkLS(indexByValue);
}
//fill out of order
{
var indexByValue = new OrderedIndex(valueKey);
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(6, 106, "A", DateTime.Now, 80)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(1, 101, "A", DateTime.Now, 1)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(4, 104, "A", DateTime.Now, 13)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(2, 102, "A", DateTime.Now, 4)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(5, 105, "A", DateTime.Now, 14)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(3, 103, "A", DateTime.Now, 6)));
checkLE(indexByValue);
checkLS(indexByValue);
}
//fill out of order transactional
{
var indexByValue = new OrderedIndex(valueKey);
indexByValue.BeginFill();
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(6, 106, "A", DateTime.Now, 80)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(1, 101, "A", DateTime.Now, 1)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(4, 104, "A", DateTime.Now, 13)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(2, 102, "A", DateTime.Now, 4)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(5, 105, "A", DateTime.Now, 14)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(3, 103, "A", DateTime.Now, 6)));
indexByValue.EndFill();
checkLE(indexByValue);
checkLS(indexByValue);
}
//all equals
{
var indexByValue = new OrderedIndex(valueKey);
var keyType = new KeyInfo(KeyDataType.IntKey, KeyType.ScalarIndex, "test", true);
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(6, 106, "A", DateTime.Now, 45)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(1, 101, "A", DateTime.Now, 45)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(4, 104, "A", DateTime.Now, 45)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(2, 102, "A", DateTime.Now, 45)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(5, 105, "A", DateTime.Now, 45)));
indexByValue.Put(CachedObject.Pack(new CacheableTypeOk(3, 103, "A", DateTime.Now, 45)));
//value not fount (too small)
var result1 = indexByValue.GetMany(MakeIntValue(12, keyType), QueryOperator.Le);
Assert.AreEqual(result1.Count, 0);
result1 = indexByValue.GetMany(MakeIntValue(12, keyType), QueryOperator.Lt);
Assert.AreEqual(result1.Count, 0);
//value not found (too big)
result1 = indexByValue.GetMany(MakeIntValue(50, keyType), QueryOperator.Le);
Assert.AreEqual(result1.Count, 6);
result1 = indexByValue.GetMany(MakeIntValue(50, keyType), QueryOperator.Lt);
Assert.AreEqual(result1.Count, 6);
//value found (all match the index key )
result1 = indexByValue.GetMany(MakeIntValue(45, keyType), QueryOperator.Le);
Assert.AreEqual(result1.Count, 6);
//not found (Lt)
result1 = indexByValue.GetMany(MakeIntValue(45, keyType), QueryOperator.Lt);
Assert.AreEqual(result1.Count, 0);
}
}
public static XmlElement GetSignature(XmlDocument document, X509Certificate2 cert, string elementToSignId)
{
SignedXml signedXml = new SignedXml(document)
{
SigningKey = cert.PrivateKey
};
signedXml.SigningKey = cert.PrivateKey;
// Create a reference to be signed.
Reference reference = new Reference()
{
Uri = elementToSignId
};
// Add an enveloped transformation to the reference.
XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform(true);
reference.AddTransform(env);
//canonicalize
XmlDsigC14NTransform c14t = new XmlDsigC14NTransform();
reference.AddTransform(c14t);
//Key Info
KeyInfoName kin = new KeyInfoName()
{
Value = cert.Subject
};
//RSA Key Provider
// RSACryptoServiceProvider rsaprovider = (RSACryptoServiceProvider)cert.PublicKey.Key;
// RSAKeyValue rkv = new RSAKeyValue(rsaprovider);
//System.Security.Cryptography..X509IssuerSerial xserial;
//xserial.IssuerName = cert.IssuerName.Name;
//xserial.SerialNumber = cert.SerialNumber;
KeyInfo keyInfo = new KeyInfo();
KeyInfoX509Data keyInfoData = new KeyInfoX509Data(cert);
//keyInfo.AddClause(new KeyInfoX509Data(cert));
keyInfoData.AddIssuerSerial(cert.IssuerName.Name, cert.SerialNumber);
keyInfo.AddClause(keyInfoData);
keyInfo.AddClause(kin);
//keyInfo.AddClause(rkv);
// Add the KeyInfo object to the SignedXml object.
keyInfo.AddClause(new RSAKeyValue((RSA)cert.PrivateKey));
signedXml.KeyInfo = keyInfo;
// Add the reference to the SignedXml object.
signedXml.AddReference(reference);
// Compute the signature.
signedXml.ComputeSignature();
// Get the XML representation of the signature and save it to an XmlElement object.
XmlElement xmlDigitalSignature = signedXml.GetXml();
return(xmlDigitalSignature);
}
private void OnKeyUp(KeyInfo info)
{
RaisePropertyChanged("TotalHits");
RaisePropertyChanged("AggregatedKeys");
}
public string FirmarXml(string tramaXml)
{
// Vamos a firmar el XML con la ruta del certificado que está como serializado.
var certificate = new X509Certificate2();
certificate.Import(Convert.FromBase64String(RutaCertificadoDigital),
PasswordCertificado, X509KeyStorageFlags.MachineKeySet);
var xmlDoc = new XmlDocument();
string resultado;
using (var documento = new MemoryStream(Convert.FromBase64String(tramaXml)))
{
xmlDoc.PreserveWhitespace = true;
xmlDoc.Load(documento);
int tipo;
if (TipoDocumento == 1 || TipoDocumento == 2 || TipoDocumento == 3 || TipoDocumento == 4)
{
tipo = 1;
}
else
{
tipo = 0;
}
var nodoExtension = xmlDoc.GetElementsByTagName("ExtensionContent", EspacioNombres.ext)
.Item(tipo);
if (nodoExtension == null)
{
throw new InvalidOperationException("No se pudo encontrar el nodo ExtensionContent en el XML");
}
nodoExtension.RemoveAll();
// Creamos el objeto SignedXml.
var signedXml = new SignedXml(xmlDoc)
{
SigningKey = (RSA)certificate.PrivateKey
};
signedXml.SigningKey = certificate.PrivateKey;
var xmlSignature = signedXml.Signature;
var env = new XmlDsigEnvelopedSignatureTransform();
var reference = new Reference(string.Empty);
reference.AddTransform(env);
xmlSignature.SignedInfo.AddReference(reference);
var keyInfo = new KeyInfo();
var x509Data = new KeyInfoX509Data(certificate);
x509Data.AddSubjectName(certificate.Subject);
keyInfo.AddClause(x509Data);
xmlSignature.KeyInfo = keyInfo;
xmlSignature.Id = "SignatureErickOrlando";
signedXml.ComputeSignature();
// Recuperamos el valor Hash de la firma para este documento.
if (reference.DigestValue != null)
{
DigestValue = Convert.ToBase64String(reference.DigestValue);
}
ValorFirma = Convert.ToBase64String(signedXml.SignatureValue);
nodoExtension.AppendChild(signedXml.GetXml());
var settings = new XmlWriterSettings()
{
Encoding = Encoding.GetEncoding("ISO-8859-1")
};
using (var memDoc = new MemoryStream())
{
using (var writer = XmlWriter.Create(memDoc, settings))
{
xmlDoc.WriteTo(writer);
}
resultado = Convert.ToBase64String(memDoc.ToArray());
}
}
return(resultado);
}
static string FindName(KeyInfo[] info, int key)
{
foreach(KeyInfo i in info) if(i.ki_key==key) return i.ki_name;
return string.Format("Unknown-{0}", key);
}
/// <summary>
/// This function does all the nasty work at determining what keys need to be returned for
/// a given statement.
/// </summary>
/// <param name="cnn"></param>
/// <param name="reader"></param>
/// <param name="stmt"></param>
internal SQLiteKeyReader(SQLiteConnection cnn, SQLiteDataReader reader, SQLiteStatement stmt)
{
Dictionary<string, int> catalogs = new Dictionary<string, int>();
Dictionary<string, List<string>> tables = new Dictionary<string, List<string>>();
List<string> list;
List<KeyInfo> keys = new List<KeyInfo>();
// Record the statement so we can use it later for sync'ing
_stmt = stmt;
// Fetch all the attached databases on this connection
using (DataTable tbl = cnn.GetSchema("Catalogs"))
{
foreach (DataRow row in tbl.Rows)
{
catalogs.Add((string)row["CATALOG_NAME"], Convert.ToInt32(row["ID"], CultureInfo.InvariantCulture));
}
}
// Fetch all the unique tables and catalogs used by the current statement
using (DataTable schema = reader.GetSchemaTable(false, false))
{
foreach (DataRow row in schema.Rows)
{
// Check if column is backed to a table
if (row[SchemaTableOptionalColumn.BaseCatalogName] == DBNull.Value)
continue;
// Record the unique table so we can look up its keys
string catalog = (string)row[SchemaTableOptionalColumn.BaseCatalogName];
string table = (string)row[SchemaTableColumn.BaseTableName];
if (tables.ContainsKey(catalog) == false)
{
list = new List<string>();
tables.Add(catalog, list);
}
else
list = tables[catalog];
if (list.Contains(table) == false)
list.Add(table);
}
// For each catalog and each table, query the indexes for the table.
// Find a primary key index if there is one. If not, find a unique index instead
foreach (KeyValuePair<string, List<string>> pair in tables)
{
for (int i = 0; i < pair.Value.Count; i++)
{
string table = pair.Value[i];
DataRow preferredRow = null;
using (DataTable tbl = cnn.GetSchema("Indexes", new string[] { pair.Key, null, table }))
{
// Loop twice. The first time looking for a primary key index,
// the second time looking for a unique index
for (int n = 0; n < 2 && preferredRow == null; n++)
{
foreach (DataRow row in tbl.Rows)
{
if (n == 0 && (bool)row["PRIMARY_KEY"] == true)
{
preferredRow = row;
break;
}
else if (n == 1 && (bool)row["UNIQUE"] == true)
{
preferredRow = row;
break;
}
}
}
if (preferredRow == null) // Unable to find any suitable index for this table so remove it
{
pair.Value.RemoveAt(i);
i--;
}
else // We found a usable index, so fetch the necessary table details
{
using (DataTable tblTables = cnn.GetSchema("Tables", new string[] { pair.Key, null, table }))
{
// Find the root page of the table in the current statement and get the cursor that's iterating it
int database = catalogs[pair.Key];
int rootPage = Convert.ToInt32(tblTables.Rows[0]["TABLE_ROOTPAGE"], CultureInfo.InvariantCulture);
int cursor = stmt._sql.GetCursorForTable(stmt, database, rootPage);
// Now enumerate the members of the index we're going to use
using (DataTable indexColumns = cnn.GetSchema("IndexColumns", new string[] { pair.Key, null, table, (string)preferredRow["INDEX_NAME"] }))
{
KeyQuery query = null;
List<string> cols = new List<string>();
for (int x = 0; x < indexColumns.Rows.Count; x++)
{
bool addKey = true;
// If the column in the index already appears in the query, skip it
foreach (DataRow row in schema.Rows)
{
if (row.IsNull(SchemaTableColumn.BaseColumnName))
continue;
if ((string)row[SchemaTableColumn.BaseColumnName] == (string)indexColumns.Rows[x]["COLUMN_NAME"] &&
(string)row[SchemaTableColumn.BaseTableName] == table &&
(string)row[SchemaTableOptionalColumn.BaseCatalogName] == pair.Key)
{
indexColumns.Rows.RemoveAt(x);
x--;
addKey = false;
break;
}
}
if (addKey == true)
cols.Add((string)indexColumns.Rows[x]["COLUMN_NAME"]);
}
// If the index is not a rowid alias, record all the columns
// needed to make up the unique index and construct a SQL query for it
if ((string)preferredRow["INDEX_NAME"] != "sqlite_master_PK_" + table)
{
// Whatever remains of the columns we need that make up the index that are not
// already in the query need to be queried separately, so construct a subquery
if (cols.Count > 0)
{
string[] querycols = new string[cols.Count];
cols.CopyTo(querycols);
query = new KeyQuery(cnn, pair.Key, table, querycols);
}
}
// Create a KeyInfo struct for each column of the index
for (int x = 0; x < indexColumns.Rows.Count; x++)
{
string columnName = (string)indexColumns.Rows[x]["COLUMN_NAME"];
KeyInfo key = new KeyInfo();
key.rootPage = rootPage;
key.cursor = cursor;
key.database = database;
key.databaseName = pair.Key;
key.tableName = table;
key.columnName = columnName;
key.query = query;
key.column = x;
keys.Add(key);
}
}
}
}
}
}
}
}
// Now we have all the additional columns we have to return in order to support
// CommandBehavior.KeyInfo
_keyInfo = new KeyInfo[keys.Count];
keys.CopyTo(_keyInfo);
}
// Use this for initialization
public void Initialize(KeyInfo [] animKeys)
{
Keys = new KeyInfo[animKeys.Length];
for(int i = 0; i < animKeys.Length ; i++){
Keys[i] = animKeys[i];
}
_keyCnt = Keys.Length - 2 ; // -1 because keys 0 and keys.length-1 are the same, -2 because the last frame gives extreme results
//Alloc space according to keyframe count
for(int i = 0; i < 2; i++) {
SpaceMetric[i] = new float[_keyCnt];
SpaceIndex[i] = new int[_keyCnt];
WeightMetric[i] = new float[_keyCnt];
WeightIndex[i] = new int[_keyCnt];
TimeMetric[i] = new float[_keyCnt];
TimeIndex[i] = new int[_keyCnt];
FlowMetric[i] = new float[_keyCnt -1]; //eliminate the last element as it is unnaturally big
FlowIndex[i] = new int[_keyCnt];
Curvature[i] = new float[_keyCnt];
//Initialize histograms
SpaceHist[i] = new float[NBins + 1];
TimeHist[i] = new float[NBins + 1];
FlowHist[i] = new float[NBins + 1];
WeightHist[i] = new float[NBins + 1];
CurvatureHist[i] = new float[NBins + 1];
for(int j = 0; j < NBins +1 ; j++) {
SpaceHist[i][j] = 0;
TimeHist[i][j] = 0;
FlowHist[i][j] = 0;
WeightHist[i][j] = 0;
CurvatureHist[i][j] = 0;
}
}
Segments.Clear();
KeySegments.Clear();
for(int i = 0; i < 10; i++) {
PostureMetric[i] = new float[_keyCnt]; // 10 angles for keyframes
PostureHist[i] = new float[NBins + 1];
for(int j = 0; j< NBins +1 ; j++)
PostureHist[i][j] = 0;
}
}
/* Forward reference */
//static int multiSelectOrderBy(
// Parse* pParse, /* Parsing context */
// Select* p, /* The right-most of SELECTs to be coded */
// SelectDest* pDest /* What to do with query results */
//);
#if !SQLITE_OMIT_COMPOUND_SELECT
/*
** This routine is called to process a compound query form from
** two or more separate queries using UNION, UNION ALL, EXCEPT, or
** INTERSECT
**
** "p" points to the right-most of the two queries. the query on the
** left is p.pPrior. The left query could also be a compound query
** in which case this routine will be called recursively.
**
** The results of the total query are to be written into a destination
** of type eDest with parameter iParm.
**
** Example 1: Consider a three-way compound SQL statement.
**
** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
**
** This statement is parsed up as follows:
**
** SELECT c FROM t3
** |
** `----. SELECT b FROM t2
** |
** `-----. SELECT a FROM t1
**
** The arrows in the diagram above represent the Select.pPrior pointer.
** So if this routine is called with p equal to the t3 query, then
** pPrior will be the t2 query. p.op will be TK_UNION in this case.
**
** Notice that because of the way SQLite parses compound SELECTs, the
** individual selects always group from left to right.
*/
static int multiSelect(
Parse pParse, /* Parsing context */
Select p, /* The right-most of SELECTs to be coded */
SelectDest pDest /* What to do with query results */
)
{
int rc = SQLITE_OK; /* Success code from a subroutine */
Select pPrior; /* Another SELECT immediately to our left */
Vdbe v; /* Generate code to this VDBE */
SelectDest dest = new SelectDest(); /* Alternative data destination */
Select pDelete = null; /* Chain of simple selects to delete */
sqlite3 db; /* Database connection */
#if !SQLITE_OMIT_EXPLAIN
int iSub1 = 0; /* EQP id of left-hand query */
int iSub2 = 0; /* EQP id of right-hand query */
#endif
/* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
*/
Debug.Assert( p != null && p.pPrior != null ); /* Calling function guarantees this much */
db = pParse.db;
pPrior = p.pPrior;
Debug.Assert( pPrior.pRightmost != pPrior );
Debug.Assert( pPrior.pRightmost == p.pRightmost );
dest = pDest;
if ( pPrior.pOrderBy != null )
{
sqlite3ErrorMsg( pParse, "ORDER BY clause should come after %s not before",
selectOpName( p.op ) );
rc = 1;
goto multi_select_end;
}
if ( pPrior.pLimit != null )
{
sqlite3ErrorMsg( pParse, "LIMIT clause should come after %s not before",
selectOpName( p.op ) );
rc = 1;
goto multi_select_end;
}
v = sqlite3GetVdbe( pParse );
Debug.Assert( v != null ); /* The VDBE already created by calling function */
/* Create the destination temporary table if necessary
*/
if ( dest.eDest == SRT_EphemTab )
{
Debug.Assert( p.pEList != null );
sqlite3VdbeAddOp2( v, OP_OpenEphemeral, dest.iParm, p.pEList.nExpr );
sqlite3VdbeChangeP5( v, BTREE_UNORDERED );
dest.eDest = SRT_Table;
}
/* Make sure all SELECTs in the statement have the same number of elements
** in their result sets.
*/
Debug.Assert( p.pEList != null && pPrior.pEList != null );
if ( p.pEList.nExpr != pPrior.pEList.nExpr )
{
sqlite3ErrorMsg( pParse, "SELECTs to the left and right of %s" +
" do not have the same number of result columns", selectOpName( p.op ) );
rc = 1;
goto multi_select_end;
}
/* Compound SELECTs that have an ORDER BY clause are handled separately.
*/
if ( p.pOrderBy != null )
{
return multiSelectOrderBy( pParse, p, pDest );
}
/* Generate code for the left and right SELECT statements.
*/
switch ( p.op )
{
case TK_ALL:
{
int addr = 0;
int nLimit = 0;
Debug.Assert( pPrior.pLimit == null );
pPrior.pLimit = p.pLimit;
pPrior.pOffset = p.pOffset;
explainSetInteger( ref iSub1, pParse.iNextSelectId );
rc = sqlite3Select( pParse, pPrior, ref dest );
p.pLimit = null;
p.pOffset = null;
if ( rc != 0 )
{
goto multi_select_end;
}
p.pPrior = null;
p.iLimit = pPrior.iLimit;
p.iOffset = pPrior.iOffset;
if ( p.iLimit != 0 )
{
addr = sqlite3VdbeAddOp1( v, OP_IfZero, p.iLimit );
#if SQLITE_DEBUG
VdbeComment( v, "Jump ahead if LIMIT reached" );
#endif
}
explainSetInteger( ref iSub2, pParse.iNextSelectId );
rc = sqlite3Select( pParse, p, ref dest );
testcase( rc != SQLITE_OK );
pDelete = p.pPrior;
p.pPrior = pPrior;
p.nSelectRow += pPrior.nSelectRow;
if ( pPrior.pLimit != null
&& sqlite3ExprIsInteger( pPrior.pLimit, ref nLimit ) != 0
&& p.nSelectRow > (double)nLimit
)
{
p.nSelectRow = (double)nLimit;
}
if ( addr != 0 )
{
sqlite3VdbeJumpHere( v, addr );
}
break;
}
case TK_EXCEPT:
case TK_UNION:
{
int unionTab; /* VdbeCursor number of the temporary table holding result */
u8 op = 0; /* One of the SRT_ operations to apply to self */
int priorOp; /* The SRT_ operation to apply to prior selects */
Expr pLimit, pOffset; /* Saved values of p.nLimit and p.nOffset */
int addr;
SelectDest uniondest = new SelectDest();
testcase( p.op == TK_EXCEPT );
testcase( p.op == TK_UNION );
priorOp = SRT_Union;
if ( dest.eDest == priorOp && ALWAYS( null == p.pLimit && null == p.pOffset ) )
{
/* We can reuse a temporary table generated by a SELECT to our
** right.
*/
Debug.Assert( p.pRightmost != p ); /* Can only happen for leftward elements
** of a 3-way or more compound */
Debug.Assert( p.pLimit == null ); /* Not allowed on leftward elements */
Debug.Assert( p.pOffset == null ); /* Not allowed on leftward elements */
unionTab = dest.iParm;
}
else
{
/* We will need to create our own temporary table to hold the
** intermediate results.
*/
unionTab = pParse.nTab++;
Debug.Assert( p.pOrderBy == null );
addr = sqlite3VdbeAddOp2( v, OP_OpenEphemeral, unionTab, 0 );
Debug.Assert( p.addrOpenEphm[0] == -1 );
p.addrOpenEphm[0] = addr;
p.pRightmost.selFlags |= SF_UsesEphemeral;
Debug.Assert( p.pEList != null );
}
/* Code the SELECT statements to our left
*/
Debug.Assert( pPrior.pOrderBy == null );
sqlite3SelectDestInit( uniondest, priorOp, unionTab );
explainSetInteger( ref iSub1, pParse.iNextSelectId );
rc = sqlite3Select( pParse, pPrior, ref uniondest );
if ( rc != 0 )
{
goto multi_select_end;
}
/* Code the current SELECT statement
*/
if ( p.op == TK_EXCEPT )
{
op = SRT_Except;
}
else
{
Debug.Assert( p.op == TK_UNION );
op = SRT_Union;
}
p.pPrior = null;
pLimit = p.pLimit;
p.pLimit = null;
pOffset = p.pOffset;
p.pOffset = null;
uniondest.eDest = op;
explainSetInteger( ref iSub2, pParse.iNextSelectId );
rc = sqlite3Select( pParse, p, ref uniondest );
testcase( rc != SQLITE_OK );
/* Query flattening in sqlite3Select() might refill p.pOrderBy.
** Be sure to delete p.pOrderBy, therefore, to avoid a memory leak. */
sqlite3ExprListDelete( db, ref p.pOrderBy );
pDelete = p.pPrior;
p.pPrior = pPrior;
p.pOrderBy = null;
if ( p.op == TK_UNION )
p.nSelectRow += pPrior.nSelectRow;
sqlite3ExprDelete( db, ref p.pLimit );
p.pLimit = pLimit;
p.pOffset = pOffset;
p.iLimit = 0;
p.iOffset = 0;
/* Convert the data in the temporary table into whatever form
** it is that we currently need.
*/
Debug.Assert( unionTab == dest.iParm || dest.eDest != priorOp );
if ( dest.eDest != priorOp )
{
int iCont, iBreak, iStart;
Debug.Assert( p.pEList != null );
if ( dest.eDest == SRT_Output )
{
Select pFirst = p;
while ( pFirst.pPrior != null )
pFirst = pFirst.pPrior;
generateColumnNames( pParse, null, pFirst.pEList );
}
iBreak = sqlite3VdbeMakeLabel( v );
iCont = sqlite3VdbeMakeLabel( v );
computeLimitRegisters( pParse, p, iBreak );
sqlite3VdbeAddOp2( v, OP_Rewind, unionTab, iBreak );
iStart = sqlite3VdbeCurrentAddr( v );
selectInnerLoop( pParse, p, p.pEList, unionTab, p.pEList.nExpr,
null, -1, dest, iCont, iBreak );
sqlite3VdbeResolveLabel( v, iCont );
sqlite3VdbeAddOp2( v, OP_Next, unionTab, iStart );
sqlite3VdbeResolveLabel( v, iBreak );
sqlite3VdbeAddOp2( v, OP_Close, unionTab, 0 );
}
break;
}
default:
Debug.Assert( p.op == TK_INTERSECT );
{
int tab1, tab2;
int iCont, iBreak, iStart;
Expr pLimit, pOffset;
int addr;
SelectDest intersectdest = new SelectDest();
int r1;
/* INTERSECT is different from the others since it requires
** two temporary tables. Hence it has its own case. Begin
** by allocating the tables we will need.
*/
tab1 = pParse.nTab++;
tab2 = pParse.nTab++;
Debug.Assert( p.pOrderBy == null );
addr = sqlite3VdbeAddOp2( v, OP_OpenEphemeral, tab1, 0 );
Debug.Assert( p.addrOpenEphm[0] == -1 );
p.addrOpenEphm[0] = addr;
p.pRightmost.selFlags |= SF_UsesEphemeral;
Debug.Assert( p.pEList != null );
/* Code the SELECTs to our left into temporary table "tab1".
*/
sqlite3SelectDestInit( intersectdest, SRT_Union, tab1 );
explainSetInteger( ref iSub1, pParse.iNextSelectId );
rc = sqlite3Select( pParse, pPrior, ref intersectdest );
if ( rc != 0 )
{
goto multi_select_end;
}
/* Code the current SELECT into temporary table "tab2"
*/
addr = sqlite3VdbeAddOp2( v, OP_OpenEphemeral, tab2, 0 );
Debug.Assert( p.addrOpenEphm[1] == -1 );
p.addrOpenEphm[1] = addr;
p.pPrior = null;
pLimit = p.pLimit;
p.pLimit = null;
pOffset = p.pOffset;
p.pOffset = null;
intersectdest.iParm = tab2;
explainSetInteger( ref iSub2, pParse.iNextSelectId );
rc = sqlite3Select( pParse, p, ref intersectdest );
testcase( rc != SQLITE_OK );
p.pPrior = pPrior;
if ( p.nSelectRow > pPrior.nSelectRow )
p.nSelectRow = pPrior.nSelectRow;
sqlite3ExprDelete( db, ref p.pLimit );
p.pLimit = pLimit;
p.pOffset = pOffset;
/* Generate code to take the intersection of the two temporary
** tables.
*/
Debug.Assert( p.pEList != null );
if ( dest.eDest == SRT_Output )
{
Select pFirst = p;
while ( pFirst.pPrior != null )
pFirst = pFirst.pPrior;
generateColumnNames( pParse, null, pFirst.pEList );
}
iBreak = sqlite3VdbeMakeLabel( v );
iCont = sqlite3VdbeMakeLabel( v );
computeLimitRegisters( pParse, p, iBreak );
sqlite3VdbeAddOp2( v, OP_Rewind, tab1, iBreak );
r1 = sqlite3GetTempReg( pParse );
iStart = sqlite3VdbeAddOp2( v, OP_RowKey, tab1, r1 );
sqlite3VdbeAddOp4Int( v, OP_NotFound, tab2, iCont, r1, 0 );
sqlite3ReleaseTempReg( pParse, r1 );
selectInnerLoop( pParse, p, p.pEList, tab1, p.pEList.nExpr,
null, -1, dest, iCont, iBreak );
sqlite3VdbeResolveLabel( v, iCont );
sqlite3VdbeAddOp2( v, OP_Next, tab1, iStart );
sqlite3VdbeResolveLabel( v, iBreak );
sqlite3VdbeAddOp2( v, OP_Close, tab2, 0 );
sqlite3VdbeAddOp2( v, OP_Close, tab1, 0 );
break;
}
}
explainComposite( pParse, p.op, iSub1, iSub2, p.op != TK_ALL );
/* Compute collating sequences used by
** temporary tables needed to implement the compound select.
** Attach the KeyInfo structure to all temporary tables.
**
** This section is run by the right-most SELECT statement only.
** SELECT statements to the left always skip this part. The right-most
** SELECT might also skip this part if it has no ORDER BY clause and
** no temp tables are required.
*/
if ( ( p.selFlags & SF_UsesEphemeral ) != 0 )
{
int i; /* Loop counter */
KeyInfo pKeyInfo; /* Collating sequence for the result set */
Select pLoop; /* For looping through SELECT statements */
CollSeq apColl; /* For looping through pKeyInfo.aColl[] */
int nCol; /* Number of columns in result set */
Debug.Assert( p.pRightmost == p );
nCol = p.pEList.nExpr;
pKeyInfo = new KeyInfo(); //sqlite3DbMallocZero(db,
pKeyInfo.aColl = new CollSeq[nCol]; //sizeof(*pKeyInfo)+nCol*(CollSeq*.Length + 1));
//if ( pKeyInfo == null )
//{
// rc = SQLITE_NOMEM;
// goto multi_select_end;
//}
pKeyInfo.enc = db.aDbStatic[0].pSchema.enc;// ENC( pParse.db );
pKeyInfo.nField = (u16)nCol;
for ( i = 0; i < nCol; i++ )
{//, apColl++){
apColl = multiSelectCollSeq( pParse, p, i );
if ( null == apColl )
{
apColl = db.pDfltColl;
}
pKeyInfo.aColl[i] = apColl;
}
for ( pLoop = p; pLoop != null; pLoop = pLoop.pPrior )
{
for ( i = 0; i < 2; i++ )
{
int addr = pLoop.addrOpenEphm[i];
if ( addr < 0 )
{
/* If [0] is unused then [1] is also unused. So we can
** always safely abort as soon as the first unused slot is found */
Debug.Assert( pLoop.addrOpenEphm[1] < 0 );
break;
}
sqlite3VdbeChangeP2( v, addr, nCol );
sqlite3VdbeChangeP4( v, addr, pKeyInfo, P4_KEYINFO );
pLoop.addrOpenEphm[i] = -1;
}
}
sqlite3DbFree( db, ref pKeyInfo );
}
multi_select_end:
pDest.iMem = dest.iMem;
pDest.nMem = dest.nMem;
sqlite3SelectDelete( db, ref pDelete );
return rc;
}
//P4_KEYINFO
static void sqlite3VdbeChangeP4( Vdbe p, int addr, KeyInfo pKeyInfo, int n )
{
union_p4 _p4 = new union_p4();
_p4.pKeyInfo = pKeyInfo;
sqlite3VdbeChangeP4( p, addr, _p4, n );
}
/*
** Alternative compound select code generator for cases when there
** is an ORDER BY clause.
**
** We assume a query of the following form:
**
** <selectA> <operator> <selectB> ORDER BY <orderbylist>
**
** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
** is to code both <selectA> and <selectB> with the ORDER BY clause as
** co-routines. Then run the co-routines in parallel and merge the results
** into the output. In addition to the two coroutines (called selectA and
** selectB) there are 7 subroutines:
**
** outA: Move the output of the selectA coroutine into the output
** of the compound query.
**
** outB: Move the output of the selectB coroutine into the output
** of the compound query. (Only generated for UNION and
** UNION ALL. EXCEPT and INSERTSECT never output a row that
** appears only in B.)
**
** AltB: Called when there is data from both coroutines and A<B.
**
** AeqB: Called when there is data from both coroutines and A==B.
**
** AgtB: Called when there is data from both coroutines and A>B.
**
** EofA: Called when data is exhausted from selectA.
**
** EofB: Called when data is exhausted from selectB.
**
** The implementation of the latter five subroutines depend on which
** <operator> is used:
**
**
** UNION ALL UNION EXCEPT INTERSECT
** ------------- ----------------- -------------- -----------------
** AltB: outA, nextA outA, nextA outA, nextA nextA
**
** AeqB: outA, nextA nextA nextA outA, nextA
**
** AgtB: outB, nextB outB, nextB nextB nextB
**
** EofA: outB, nextB outB, nextB halt halt
**
** EofB: outA, nextA outA, nextA outA, nextA halt
**
** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
** causes an immediate jump to EofA and an EOF on B following nextB causes
** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or
** following nextX causes a jump to the end of the select processing.
**
** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
** within the output subroutine. The regPrev register set holds the previously
** output value. A comparison is made against this value and the output
** is skipped if the next results would be the same as the previous.
**
** The implementation plan is to implement the two coroutines and seven
** subroutines first, then put the control logic at the bottom. Like this:
**
** goto Init
** coA: coroutine for left query (A)
** coB: coroutine for right query (B)
** outA: output one row of A
** outB: output one row of B (UNION and UNION ALL only)
** EofA: ...
** EofB: ...
** AltB: ...
** AeqB: ...
** AgtB: ...
** Init: initialize coroutine registers
** yield coA
** if eof(A) goto EofA
** yield coB
** if eof(B) goto EofB
** Cmpr: Compare A, B
** Jump AltB, AeqB, AgtB
** End: ...
**
** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
** actually called using Gosub and they do not Return. EofA and EofB loop
** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
** and AgtB jump to either L2 or to one of EofA or EofB.
*/
#if !SQLITE_OMIT_COMPOUND_SELECT
static int multiSelectOrderBy(
Parse pParse, /* Parsing context */
Select p, /* The right-most of SELECTs to be coded */
SelectDest pDest /* What to do with query results */
)
{
int i, j; /* Loop counters */
Select pPrior; /* Another SELECT immediately to our left */
Vdbe v; /* Generate code to this VDBE */
SelectDest destA = new SelectDest(); /* Destination for coroutine A */
SelectDest destB = new SelectDest(); /* Destination for coroutine B */
int regAddrA; /* Address register for select-A coroutine */
int regEofA; /* Flag to indicate when select-A is complete */
int regAddrB; /* Address register for select-B coroutine */
int regEofB; /* Flag to indicate when select-B is complete */
int addrSelectA; /* Address of the select-A coroutine */
int addrSelectB; /* Address of the select-B coroutine */
int regOutA; /* Address register for the output-A subroutine */
int regOutB; /* Address register for the output-B subroutine */
int addrOutA; /* Address of the output-A subroutine */
int addrOutB = 0; /* Address of the output-B subroutine */
int addrEofA; /* Address of the select-A-exhausted subroutine */
int addrEofB; /* Address of the select-B-exhausted subroutine */
int addrAltB; /* Address of the A<B subroutine */
int addrAeqB; /* Address of the A==B subroutine */
int addrAgtB; /* Address of the A>B subroutine */
int regLimitA; /* Limit register for select-A */
int regLimitB; /* Limit register for select-A */
int regPrev; /* A range of registers to hold previous output */
int savedLimit; /* Saved value of p.iLimit */
int savedOffset; /* Saved value of p.iOffset */
int labelCmpr; /* Label for the start of the merge algorithm */
int labelEnd; /* Label for the end of the overall SELECT stmt */
int j1; /* Jump instructions that get retargetted */
int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
KeyInfo pKeyDup = null; /* Comparison information for duplicate removal */
KeyInfo pKeyMerge; /* Comparison information for merging rows */
sqlite3 db; /* Database connection */
ExprList pOrderBy; /* The ORDER BY clause */
int nOrderBy; /* Number of terms in the ORDER BY clause */
int[] aPermute; /* Mapping from ORDER BY terms to result set columns */
#if !SQLITE_OMIT_EXPLAIN
int iSub1 = 0; /* EQP id of left-hand query */
int iSub2 = 0; /* EQP id of right-hand query */
#endif
Debug.Assert( p.pOrderBy != null );
Debug.Assert( pKeyDup == null ); /* "Managed" code needs this. Ticket #3382. */
db = pParse.db;
v = pParse.pVdbe;
Debug.Assert( v != null ); /* Already thrown the error if VDBE alloc failed */
labelEnd = sqlite3VdbeMakeLabel( v );
labelCmpr = sqlite3VdbeMakeLabel( v );
/* Patch up the ORDER BY clause
*/
op = p.op;
pPrior = p.pPrior;
Debug.Assert( pPrior.pOrderBy == null );
pOrderBy = p.pOrderBy;
Debug.Assert( pOrderBy != null );
nOrderBy = pOrderBy.nExpr;
/* For operators other than UNION ALL we have to make sure that
** the ORDER BY clause covers every term of the result set. Add
** terms to the ORDER BY clause as necessary.
*/
if ( op != TK_ALL )
{
for ( i = 1; /* db.mallocFailed == 0 && */ i <= p.pEList.nExpr; i++ )
{
ExprList_item pItem;
for ( j = 0; j < nOrderBy; j++ )//, pItem++)
{
pItem = pOrderBy.a[j];
Debug.Assert( pItem.iCol > 0 );
if ( pItem.iCol == i )
break;
}
if ( j == nOrderBy )
{
Expr pNew = sqlite3Expr( db, TK_INTEGER, null );
//if ( pNew == null )
// return SQLITE_NOMEM;
pNew.flags |= EP_IntValue;
pNew.u.iValue = i;
pOrderBy = sqlite3ExprListAppend( pParse, pOrderBy, pNew );
pOrderBy.a[nOrderBy++].iCol = (u16)i;
}
}
}
/* Compute the comparison permutation and keyinfo that is used with
** the permutation used to determine if the next
** row of results comes from selectA or selectB. Also add explicit
** collations to the ORDER BY clause terms so that when the subqueries
** to the right and the left are evaluated, they use the correct
** collation.
*/
aPermute = new int[nOrderBy];// sqlite3DbMallocRaw( db, sizeof( int ) * nOrderBy );
if ( aPermute != null )
{
ExprList_item pItem;
for ( i = 0; i < nOrderBy; i++ )//, pItem++)
{
pItem = pOrderBy.a[i];
Debug.Assert( pItem.iCol > 0 && pItem.iCol <= p.pEList.nExpr );
aPermute[i] = pItem.iCol - 1;
}
pKeyMerge = new KeyInfo();// sqlite3DbMallocRaw(db, sizeof(*pKeyMerge)+nOrderBy*(sizeof(CollSeq)+1));
if ( pKeyMerge != null )
{
pKeyMerge.aColl = new CollSeq[nOrderBy];
pKeyMerge.aSortOrder = new byte[nOrderBy];//(u8)&pKeyMerge.aColl[nOrderBy];
pKeyMerge.nField = (u16)nOrderBy;
pKeyMerge.enc = ENC( db );
for ( i = 0; i < nOrderBy; i++ )
{
CollSeq pColl;
Expr pTerm = pOrderBy.a[i].pExpr;
if ( ( pTerm.flags & EP_ExpCollate ) != 0 )
{
pColl = pTerm.pColl;
}
else
{
pColl = multiSelectCollSeq( pParse, p, aPermute[i] );
pTerm.flags |= EP_ExpCollate;
pTerm.pColl = pColl;
}
pKeyMerge.aColl[i] = pColl;
pKeyMerge.aSortOrder[i] = (byte)pOrderBy.a[i].sortOrder;
}
}
}
else
{
pKeyMerge = null;
}
/* Reattach the ORDER BY clause to the query.
*/
p.pOrderBy = pOrderBy;
pPrior.pOrderBy = sqlite3ExprListDup( pParse.db, pOrderBy, 0 );
/* Allocate a range of temporary registers and the KeyInfo needed
** for the logic that removes duplicate result rows when the
** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
*/
if ( op == TK_ALL )
{
regPrev = 0;
}
else
{
int nExpr = p.pEList.nExpr;
Debug.Assert( nOrderBy >= nExpr /*|| db.mallocFailed != 0 */ );
regPrev = sqlite3GetTempRange( pParse, nExpr + 1 );
sqlite3VdbeAddOp2( v, OP_Integer, 0, regPrev );
pKeyDup = new KeyInfo();//sqlite3DbMallocZero(db,
//sizeof(*pKeyDup) + nExpr*(sizeof(CollSeq)+1) );
if ( pKeyDup != null )
{
pKeyDup.aColl = new CollSeq[nExpr];
pKeyDup.aSortOrder = new byte[nExpr];//(u8)&pKeyDup.aColl[nExpr];
pKeyDup.nField = (u16)nExpr;
pKeyDup.enc = ENC( db );
for ( i = 0; i < nExpr; i++ )
{
pKeyDup.aColl[i] = multiSelectCollSeq( pParse, p, i );
pKeyDup.aSortOrder[i] = 0;
}
}
}
/* Separate the left and the right query from one another
*/
p.pPrior = null;
sqlite3ResolveOrderGroupBy( pParse, p, p.pOrderBy, "ORDER" );
if ( pPrior.pPrior == null )
{
sqlite3ResolveOrderGroupBy( pParse, pPrior, pPrior.pOrderBy, "ORDER" );
}
/* Compute the limit registers */
computeLimitRegisters( pParse, p, labelEnd );
if ( p.iLimit != 0 && op == TK_ALL )
{
regLimitA = ++pParse.nMem;
regLimitB = ++pParse.nMem;
sqlite3VdbeAddOp2( v, OP_Copy, ( p.iOffset != 0 ) ? p.iOffset + 1 : p.iLimit,
regLimitA );
sqlite3VdbeAddOp2( v, OP_Copy, regLimitA, regLimitB );
}
else
{
regLimitA = regLimitB = 0;
}
sqlite3ExprDelete( db, ref p.pLimit );
p.pLimit = null;
sqlite3ExprDelete( db, ref p.pOffset );
p.pOffset = null;
regAddrA = ++pParse.nMem;
regEofA = ++pParse.nMem;
regAddrB = ++pParse.nMem;
regEofB = ++pParse.nMem;
regOutA = ++pParse.nMem;
regOutB = ++pParse.nMem;
sqlite3SelectDestInit( destA, SRT_Coroutine, regAddrA );
sqlite3SelectDestInit( destB, SRT_Coroutine, regAddrB );
/* Jump past the various subroutines and coroutines to the main
** merge loop
*/
j1 = sqlite3VdbeAddOp0( v, OP_Goto );
addrSelectA = sqlite3VdbeCurrentAddr( v );
/* Generate a coroutine to evaluate the SELECT statement to the
** left of the compound operator - the "A" select.
*/
VdbeNoopComment( v, "Begin coroutine for left SELECT" );
pPrior.iLimit = regLimitA;
explainSetInteger( ref iSub1, pParse.iNextSelectId );
sqlite3Select( pParse, pPrior, ref destA );
sqlite3VdbeAddOp2( v, OP_Integer, 1, regEofA );
sqlite3VdbeAddOp1( v, OP_Yield, regAddrA );
VdbeNoopComment( v, "End coroutine for left SELECT" );
/* Generate a coroutine to evaluate the SELECT statement on
** the right - the "B" select
*/
addrSelectB = sqlite3VdbeCurrentAddr( v );
VdbeNoopComment( v, "Begin coroutine for right SELECT" );
savedLimit = p.iLimit;
savedOffset = p.iOffset;
p.iLimit = regLimitB;
p.iOffset = 0;
explainSetInteger( ref iSub2, pParse.iNextSelectId );
sqlite3Select( pParse, p, ref destB );
p.iLimit = savedLimit;
p.iOffset = savedOffset;
sqlite3VdbeAddOp2( v, OP_Integer, 1, regEofB );
sqlite3VdbeAddOp1( v, OP_Yield, regAddrB );
VdbeNoopComment( v, "End coroutine for right SELECT" );
/* Generate a subroutine that outputs the current row of the A
** select as the next output row of the compound select.
*/
VdbeNoopComment( v, "Output routine for A" );
addrOutA = generateOutputSubroutine( pParse,
p, destA, pDest, regOutA,
regPrev, pKeyDup, P4_KEYINFO_HANDOFF, labelEnd );
/* Generate a subroutine that outputs the current row of the B
** select as the next output row of the compound select.
*/
if ( op == TK_ALL || op == TK_UNION )
{
VdbeNoopComment( v, "Output routine for B" );
addrOutB = generateOutputSubroutine( pParse,
p, destB, pDest, regOutB,
regPrev, pKeyDup, P4_KEYINFO_STATIC, labelEnd );
}
/* Generate a subroutine to run when the results from select A
** are exhausted and only data in select B remains.
*/
VdbeNoopComment( v, "eof-A subroutine" );
if ( op == TK_EXCEPT || op == TK_INTERSECT )
{
addrEofA = sqlite3VdbeAddOp2( v, OP_Goto, 0, labelEnd );
}
else
{
addrEofA = sqlite3VdbeAddOp2( v, OP_If, regEofB, labelEnd );
sqlite3VdbeAddOp2( v, OP_Gosub, regOutB, addrOutB );
sqlite3VdbeAddOp1( v, OP_Yield, regAddrB );
sqlite3VdbeAddOp2( v, OP_Goto, 0, addrEofA );
p.nSelectRow += pPrior.nSelectRow;
}
/* Generate a subroutine to run when the results from select B
** are exhausted and only data in select A remains.
*/
if ( op == TK_INTERSECT )
{
addrEofB = addrEofA;
if ( p.nSelectRow > pPrior.nSelectRow )
p.nSelectRow = pPrior.nSelectRow;
}
else
{
VdbeNoopComment( v, "eof-B subroutine" );
addrEofB = sqlite3VdbeAddOp2( v, OP_If, regEofA, labelEnd );
sqlite3VdbeAddOp2( v, OP_Gosub, regOutA, addrOutA );
sqlite3VdbeAddOp1( v, OP_Yield, regAddrA );
sqlite3VdbeAddOp2( v, OP_Goto, 0, addrEofB );
}
/* Generate code to handle the case of A<B
*/
VdbeNoopComment( v, "A-lt-B subroutine" );
addrAltB = sqlite3VdbeAddOp2( v, OP_Gosub, regOutA, addrOutA );
sqlite3VdbeAddOp1( v, OP_Yield, regAddrA );
sqlite3VdbeAddOp2( v, OP_If, regEofA, addrEofA );
sqlite3VdbeAddOp2( v, OP_Goto, 0, labelCmpr );
/* Generate code to handle the case of A==B
*/
if ( op == TK_ALL )
{
addrAeqB = addrAltB;
}
else if ( op == TK_INTERSECT )
{
addrAeqB = addrAltB;
addrAltB++;
}
else
{
VdbeNoopComment( v, "A-eq-B subroutine" );
addrAeqB =
sqlite3VdbeAddOp1( v, OP_Yield, regAddrA );
sqlite3VdbeAddOp2( v, OP_If, regEofA, addrEofA );
sqlite3VdbeAddOp2( v, OP_Goto, 0, labelCmpr );
}
/* Generate code to handle the case of A>B
*/
VdbeNoopComment( v, "A-gt-B subroutine" );
addrAgtB = sqlite3VdbeCurrentAddr( v );
if ( op == TK_ALL || op == TK_UNION )
{
sqlite3VdbeAddOp2( v, OP_Gosub, regOutB, addrOutB );
}
sqlite3VdbeAddOp1( v, OP_Yield, regAddrB );
sqlite3VdbeAddOp2( v, OP_If, regEofB, addrEofB );
sqlite3VdbeAddOp2( v, OP_Goto, 0, labelCmpr );
/* This code runs once to initialize everything.
*/
sqlite3VdbeJumpHere( v, j1 );
sqlite3VdbeAddOp2( v, OP_Integer, 0, regEofA );
sqlite3VdbeAddOp2( v, OP_Integer, 0, regEofB );
sqlite3VdbeAddOp2( v, OP_Gosub, regAddrA, addrSelectA );
sqlite3VdbeAddOp2( v, OP_Gosub, regAddrB, addrSelectB );
sqlite3VdbeAddOp2( v, OP_If, regEofA, addrEofA );
sqlite3VdbeAddOp2( v, OP_If, regEofB, addrEofB );
/* Implement the main merge loop
*/
sqlite3VdbeResolveLabel( v, labelCmpr );
sqlite3VdbeAddOp4( v, OP_Permutation, 0, 0, 0, aPermute, P4_INTARRAY );
sqlite3VdbeAddOp4( v, OP_Compare, destA.iMem, destB.iMem, nOrderBy,
pKeyMerge, P4_KEYINFO_HANDOFF );
sqlite3VdbeAddOp3( v, OP_Jump, addrAltB, addrAeqB, addrAgtB );
/* Release temporary registers
*/
if ( regPrev != 0 )
{
sqlite3ReleaseTempRange( pParse, regPrev, nOrderBy + 1 );
}
/* Jump to the this point in order to terminate the query.
*/
sqlite3VdbeResolveLabel( v, labelEnd );
/* Set the number of output columns
*/
if ( pDest.eDest == SRT_Output )
{
Select pFirst = pPrior;
while ( pFirst.pPrior != null )
pFirst = pFirst.pPrior;
generateColumnNames( pParse, null, pFirst.pEList );
}
/* Reassembly the compound query so that it will be freed correctly
** by the calling function */
if ( p.pPrior != null )
{
sqlite3SelectDelete( db, ref p.pPrior );
}
p.pPrior = pPrior;
/*** TBD: Insert subroutine calls to close cursors on incomplete
**** subqueries ****/
explainComposite( pParse, p.op, iSub1, iSub2, false );
return SQLITE_OK;
}
//KeyInfo
static int sqlite3VdbeAddOp4( Vdbe p, int op, int p1, int p2, int p3, KeyInfo pP4, int p4type )
{
union_p4 _p4 = new union_p4();
_p4.pKeyInfo = pP4;
int addr = sqlite3VdbeAddOp3( p, op, p1, p2, p3 );
sqlite3VdbeChangeP4( p, addr, _p4, p4type );
return addr;
}
public static KeyValue Create(KeyInfo key, params object[] segmentValues)
{
if (key.Segments.Count != segmentValues.Length) {
throw new ArgumentException();
}
return new KeyValue(key, segmentValues);
}
//Vector3 ComputeInitialSwivelAngle(ArmInfo armInfo) {
// float theta;
// Vector3 u = new Vector3(1,0,0); //Local x axis
// Vector3 n = armInfo.wrist.position - armInfo.shoulder.position;
// Vector3 c = HandleUtility.ProjectPointLine (armInfo.elbow.position, armInfo.shoulder.position, armInfo.wrist.position);
// Vector3 pcap = armInfo.elbow.position - c;
// Vector3 ptilda = pcap - Vector3.Dot (pcap, n) * n;
// theta = Mathf.Atan2(Vector3.Cross(pcap, u).magnitude , Vector3.Dot (ptilda,u));
// return new Vector3(theta,0,0);
//}
//ARminfo is passed as a transform because animation is sampled
//We want the end effector position at the sampled time
public void InitKeyPoints()
{
TorsoController torso = GetComponent<TorsoController>();
ArmInfo[] arms = GetComponent<ArmController>().Arms;
AssignGoalKeys();
#if EDITORMODE
// AnimationClipCurveData[] curveDatas = AnimationUtility.GetAllCurves(animation[animName].clip, true);
// Keyframe[] frames = curveDatas[0].curve.keys;
//AnimationCurve xCurve = AnimationUtility.GetEditorCurve(animation[animName].clip,"Hips/Spine/Spine1/RightShoulder/RightArm/RightForeArm/RightHand",typeof(Transform),"m_LocalRotation.x");
//forearm keys are fewer in number, looks better with EMOTE
//AnimationCurve xCurve = AnimationUtility.GetEditorCurve(animation[AnimName].clip, "Hips/Spine/Spine1/RightShoulder/RightArm/RightForeArm", typeof(Transform), "m_LocalRotation.x");
AnimationCurve xCurve = AnimationUtility.GetEditorCurve(animation[AnimName].clip, "Hips/Spine/Spine1/RightShoulder/RightArm", typeof(Transform), "m_LocalRotation.x");
Keyframe[] frames = xCurve.keys;
using (StreamWriter sw = new StreamWriter("keyframes_" + AnimName + ".txt")) {
sw.WriteLine("MyKeyTimes = new float" + "[" + frames.Length + "];");
foreach (Keyframe kf in frames) {
sw.WriteLine("MyKeyTimes[i++] = " + kf.time + "f; ");
}
}
Debug.Log(AnimName);
#elif !EDITORMODE
//file io does not work in web player
/* string[] content = File.ReadAllLines("keyframes.txt");
MyKeyframe[] frames = new MyKeyframe[content.Length];
for (int i = 0; i < content.Length; i++) {
frames[i] = new MyKeyframe();
frames[i].time = float.Parse(content[i]);
}*/
//Will write IO operations later
MyKeyframe[] frames = new MyKeyframe[MyKeyTimes.Length];
for (int i = 0; i < MyKeyTimes.Length; i++) {
frames[i] = new MyKeyframe();
frames[i].Time = MyKeyTimes[i];
}
#endif
animation.Play(AnimName);
int goalKeyInd = 0;
Keys = new KeyInfo[frames.Length ];
for(int i = 0; i < frames.Length; i++) {
animation[AnimName].enabled = true;
animation[AnimName].time = frames[i].Time;
animation.Sample ();
Keys[i] = new KeyInfo();
Keys[i].Time = animation[AnimName].time;
//Keys[i].Time = animation[AnimName].length * i / (frames.Length - 1); //FUNDA : If we are using equally-spaced keys. We still sample from original frames, but we change key times.
if(i == GoalKeys[goalKeyInd]) {
Keys[i].IsGoal = true;
goalKeyInd++;
}
else if(i < GoalKeys[goalKeyInd])
Keys[i].IsGoal = false;
if (Keys[i].FrameNo >= FrameCnt) {
Keys[i].FrameNo = FrameCnt - 1;
}
//body chain and transformation arrays for the specific animation
BodyChain = torso.BodyChainToArray(torso.Torso.Root);
Keys[i].BodyPos = torso.BodyPosArr(BodyChain);
Keys[i].BodyRot = torso.BodyRotArr(BodyChain);
/*
BodyChain = torso.BodyChain;
Keys[i].BodyPos = torso.BodyPos;
Keys[i].BodyRot = torso.BodyRot;
*/
for(int arm = 0; arm < 2; arm++) {
Keys[i].ShoulderPos[arm] = Keys[i].ShoulderPosOrig[arm] = arms[arm].Shoulder.position;
Keys[i].EePos[arm] = Keys[i].EePosOrig[arm] = arms[arm].Wrist.position;
Keys[i].ElbowRot[arm] = Keys[i].ElbowRotOrig[arm] = arms[arm].Elbow.localRotation;
Keys[i].ElbowPos[arm] = Keys[i].ElbowPosOrig[arm] = arms[arm].Elbow.position;
}
}
animation.Stop(AnimName);
animation.enabled = false;
}
//Gets only transform Keys
public void InitKeyPoints()
{
ArmInfo[] arms = GetComponent<ArmController>().Arms;
TorsoInfo torso = GetComponent<TorsoController>().Torso;
#if EDITORMODE
//Rotation x, y and z curves are the same, so one is enough
//No keypoints defined for localTransform
AnimationCurve xCurve = AnimationUtility.GetEditorCurve(animation[AnimName].clip,"Hips/Spine/Spine1/RightShoulder/RightArm/RightForeArm/RightHand",typeof(Transform),"m_LocalRotation.x");
Keyframe[] frames = xCurve.keys;
//Keyframe[] frames =animation[AnimName].;
Keys = new KeyInfo[frames.Length];
//all frames as Keys Keys = new KeyInfo[frameCnt ];
for(int i = 0; i < Keys.Length; i++) {
animation[AnimName].time = frames[i].time;//(float) Keys[i].frameNo / animation[AnimName].clip.frameRate;
//animation[AnimName].time = i/animation[AnimName].clip.frameRate;//(float) Keys[i].frameNo / animation[AnimName].clip.frameRate;
animation.Sample ();
Keys[i] = new KeyInfo();
Keys[i].FrameNo = Mathf.FloorToInt(animation[AnimName].time * animation[AnimName].clip.frameRate);
Keys[i].Time = animation[AnimName].time;
for(int arm = 0; arm < 2; arm++) {
Keys[i].EePos[arm] = Keys[i].EePosOrig[arm] = arms[arm].Wrist.position;
}
Keys[i].ClavicleLRot = torso.ClavicleL.rotation;
Keys[i].ClavicleRRot = torso.ClavicleR.rotation;
Keys[i].NeckRot = torso.Neck.rotation;
Keys[i].SpineRot = torso.Spine.rotation;
Keys[i].Spine1Rot = torso.Spine1.rotation;
Keys[i].ElbowLRot = torso.ElbowL.rotation;
Keys[i].ElbowRRot = torso.ElbowR.rotation;
Keys[i].ClavicleLPos = torso.ClavicleL.position;
Keys[i].ClavicleRPos = torso.ClavicleR.position;
Keys[i].NeckPos = torso.Neck.position;
Keys[i].SpinePos = torso.Spine.position;
Keys[i].Spine1Pos = torso.Spine1.position;
Keys[i].ElbowLPos = torso.ElbowL.position;
Keys[i].ElbowRPos = torso.ElbowR.position;
}
//Compute end effector velocity
for(int i = 0; i < Keys.Length; i++) {
for(int arm = 0; arm < 2; arm++) {
if(i == 0)
Keys[0].EeVel[arm] = (Keys[1].EePos[arm] - Keys[0].EePos[arm]) / (Keys[1].Time - Keys[0].Time);
else if(i == Keys.Length - 1)
Keys[Keys.Length - 1].EeVel[arm] = (Keys[Keys.Length - 1].EePos[arm] - Keys[Keys.Length - 2].EePos[arm]) / (Keys[Keys.Length - 1].Time - Keys[Keys.Length - 2].Time);
else
Keys[i].EeVel[arm] = (Keys[i + 1].EePos[arm] - Keys[i - 1].EePos[arm]) / (Keys[i + 1].Time - Keys[i - 1].Time);
}
}
//Compute end effector acceleration
for(int i = 0; i < Keys.Length; i++) {
for(int arm = 0; arm < 2; arm++) {
if(i == 0)
Keys[0].EeAcc[arm] = (Keys[1].EeVel[arm] - Keys[0].EeVel[arm]) / (Keys[1].Time - Keys[0].Time);
else if(i == Keys.Length - 1)
Keys[Keys.Length - 1].EeAcc[arm] = (Keys[Keys.Length - 1].EeVel[arm] - Keys[Keys.Length - 2].EeVel[arm]) / (Keys[Keys.Length - 1].Time - Keys[Keys.Length - 2].Time);
else
Keys[i].EeAcc[arm] = (Keys[i + 1].EeVel[arm] - Keys[i - 1].EeVel[arm]) / (Keys[i + 1].Time - Keys[i - 1].Time);
}
}
#endif
}
private static IList <KeyValue> MakeIntValue(int value, KeyInfo type)
{
return(new List <KeyValue> {
new KeyValue(value, type)
});
}
/// <summary>
/// Return the key object
/// </summary>
/// <param name="rootfiles"></param>
/// <param name="treename"></param>
/// <param name="inputObjects"></param>
/// <param name="query"></param>
/// <returns></returns>
public IQueryResultCacheKey GetKey(Uri[] unsortedRootfiles, string treename, object[] inputObjects,
string[] unsortedCrumbs,
QueryModel query,
bool recheckDates = false,
Func <Uri, DateTime> dateChecker = null)
{
///
/// Quick check to make sure everything is good
///
TraceHelpers.TraceInfo(23, "GetKey: Initial query calculation");
if (unsortedRootfiles.Any(f => f == null))
{
throw new ArgumentException("one of the root files is null");
}
if (string.IsNullOrWhiteSpace(treename))
{
throw new ArgumentException("tree name must be valid");
}
if (inputObjects != null && inputObjects.Any(o => o == null))
{
throw new ArgumentException("one of the input objects is null - not allowed");
}
///
/// Build the hash, which is a bit of a pain in the butt.
/// For the root files we don't care about the order given to us in or the order they
/// are processed in. What we care about is what is there!
///
var rootfiles = (from r in unsortedRootfiles
orderby r.OriginalString ascending
select r).ToArray();
TraceHelpers.TraceInfo(24, "GetKey: Creating big string file name and calculating hash");
int fnameLength = rootfiles.Select(f => f.OriginalString).Sum(w => w.Length) + 100;
StringBuilder fullSourceName = new StringBuilder(fnameLength);
foreach (var f in rootfiles)
{
fullSourceName.Append(f.OriginalString);
}
var fileHash = fullSourceName.ToString().GetHashCode();
//
// Next, the crumbs. They should also be sorted in order, and we will need
// a hash code for them too.
//
string[] crumbs = null;
int crumbHash = 0;
if (unsortedCrumbs == null)
{
crumbs = new string[0];
}
else
{
crumbs = (from c in unsortedCrumbs orderby c select c).Distinct().ToArray();
StringBuilder crumbString = new StringBuilder();
foreach (var c in crumbs)
{
crumbString.Append(c);
}
crumbHash = crumbString.ToString().GetHashCode();
}
///
/// Save the names of the files for a descriptor we will write out.
///
KeyInfo result = new KeyInfo();
TraceHelpers.TraceInfo(25, "GetKey: Saving description lines");
result.DescriptionLines = (from f in rootfiles
select f.OriginalString).ToArray();
result.ExtraQueryInfoLines = crumbs;
///
/// Text for the query. There are strings like "generated_x" where x is a number. These get incremented each time they are used,
/// so to protect the caching we need to swap those out with a dummy.
///
TraceHelpers.TraceInfo(26, "GetKey: Pretty printing the query");
result.QueryText = FormattingQueryVisitor.Format(query);
result.QueryText = result.QueryText.SwapOutWithUninqueString("\\<generated\\>_[0-9]+");
///
/// And the directory name - we use the first name of the file.
///
TraceHelpers.TraceInfo(27, "GetKey: Getting the cache directory");
var fpathName = Path.GetFileNameWithoutExtension(rootfiles[0].PathAndQuery.SanitizedPathName(100));
result.CacheDirectory = new DirectoryInfo(CacheDirectory.FullName + "\\" + fileHash + " - " + treename + "-" + fpathName);
///
/// Scan the files that we are input and find the oldest one there
///
TraceHelpers.TraceInfo(28, "GetKey: calculating the most recent file dates");
result.OldestSourceFileDate = GetRecentFileDates(rootfiles, recheckDates, dateChecker).Max();
///
/// And now the file that the query should be cached in
///
TraceHelpers.TraceInfo(29, "GetKey: Calculating query hash");
var queryHash = result.QueryText.GetHashCode();
TraceHelpers.TraceInfo(30, "GetKey: Calculating the input object hash");
var inputObjectHash = CalcObjectHash(inputObjects);
string queryNameBase = string.Format(@"\\query {0}-inp{1}-crm{2}", queryHash.ToString(), inputObjectHash, crumbHash);
result.RootFile = new FileInfo(result.CacheDirectory.FullName + queryNameBase + "_%%CYCLE%%.root");
// And a complete unique hash string.
result.UniqueHashString = $"files{fileHash.ToString()}-query{queryHash.ToString()}-objs{inputObjectHash}-crm{crumbHash}";
TraceHelpers.TraceInfo(31, "GetKey: Done");
return(result);
}
public static KeyValue MaximumComplement(KeyInfo key, params object[] segmentValues)
{
return new KeyValue(key, segmentValues, false);
}
private static IList <KeyValue> MakeStringValue(string value, KeyInfo type)
{
return(new List <KeyValue> {
new KeyValue(value, type)
});
}
/// <summary>
/// Computes the key info dictionary for the column metadata of the
/// given data reader.
/// </summary>
/// <remarks>
/// Depending upon the column metadata already present in the data
/// reader, it may be required to perform further access to the
/// originating data source using the reader's
/// <c>OriginatingConnection</c>. This in turn implies that the
/// <c>OriginatingConnection</c> must be open and must still
/// represent the originating session on the originating data source;
/// otherwise, the reported key info may be incorrect or the attempt
/// access the data source may simply fail.
/// </remarks>
/// <param name="reader">
/// The reader for which to compute the column metadata key info map.
/// </param>
/// <returns>
/// Map {ColumnIdentifier=>KeyInfo}
/// </returns>
/// <exception cref="HsqlDataSourceException">
/// If a data access error occurs.
/// </exception>
internal static Dictionary <ColumnIdentifier, KeyInfo> GetKeyInfo(
HsqlDataReader reader)
{
ResultMetaData metaData = reader.m_result.metaData;
Dictionary <TableIdentifier, object> tableSet
= new Dictionary <TableIdentifier, object>();
object placeholder = new object();
string[] schemaNames = metaData.schemaNames;
string[] tableNames = metaData.tableNames;
string[] columnNames = metaData.colNames;
int count = columnNames.Length;
for (int i = 0; i < count; i++)
{
string tableName = tableNames[i];
string columnName = columnNames[i];
if (string.IsNullOrEmpty(tableName) ||
string.IsNullOrEmpty(columnName))
{ // not a table column
continue;
}
string schemaName = schemaNames[i];
TableIdentifier tableIdentifier = new TableIdentifier(
schemaName, tableName);
tableSet[tableIdentifier] = placeholder;
}
Dictionary <ColumnIdentifier, KeyInfo> columnMap
= new Dictionary <ColumnIdentifier, KeyInfo>();
if (tableSet.Count == 0)
{
return(columnMap);
}
StringBuilder sb = new StringBuilder('(');
count = 0;
foreach (TableIdentifier tableIdentifier in tableSet.Keys)
{
if (count > 0)
{
sb.Append(" OR ");
}
count++;
sb.Append("(bri.table_schem");
string schemaName = tableIdentifier.m_schema;
if (string.IsNullOrEmpty(schemaName))
{
sb.Append(" IS NULL ");
}
else
{
sb.Append(" = ").Append(StringConverter.toQuotedString(
schemaName, '\'', /*escape inner quotes*/ true));
}
string tableName = tableIdentifier.m_table;
sb.Append(" AND bri.table_name = ").Append(
StringConverter.toQuotedString(tableName, '\'',
/*escape inner quotes*/ true));
sb.Append(')');
}
sb.Append(')');
string predicate = sb.ToString();
using (HsqlCommand command =
reader.OriginatingConnection.CreateCommand())
{
command.CommandText = string.Format(KeyInfoQuery, predicate);
command.CommandType = CommandType.Text;
using (HsqlDataReader keyInfoReader = command.ExecuteReader())
{
while (keyInfoReader.Read())
{
bool isKey = keyInfoReader.GetBoolean(3);
if (!isKey)
{
continue;
}
string schema = keyInfoReader.GetString(0);
string table = keyInfoReader.GetString(1);
string column = keyInfoReader.GetString(2);
ColumnIdentifier key = new ColumnIdentifier(schema,
table, column);
if (!columnMap.ContainsKey(key))
{
KeyInfo keyInfo = new KeyInfo();
keyInfo.m_isKey = true;
keyInfo.m_isUnique = false;
columnMap.Add(key, keyInfo);
}
}
}
}
return(columnMap);
}
/*
** Generate code to do an analysis of all indices associated with
** a single table.
*/
static void analyzeOneTable(
Parse pParse, /* Parser context */
Table pTab, /* Table whose indices are to be analyzed */
int iStatCur, /* Index of VdbeCursor that writes the sqlite_stat1 table */
int iMem /* Available memory locations begin here */
)
{
Index pIdx; /* An index to being analyzed */
int iIdxCur; /* Index of VdbeCursor for index being analyzed */
int nCol; /* Number of columns in the index */
Vdbe v; /* The virtual machine being built up */
int i; /* Loop counter */
int topOfLoop; /* The top of the loop */
int endOfLoop; /* The end of the loop */
int addr; /* The address of an instruction */
int iDb; /* Index of database containing pTab */
v = sqlite3GetVdbe(pParse);
if (v == null || NEVER(pTab == null) || pTab.pIndex == null)
{
/* Do no analysis for tables that have no indices */
return;
}
Debug.Assert(sqlite3BtreeHoldsAllMutexes(pParse.db));
iDb = sqlite3SchemaToIndex(pParse.db, pTab.pSchema);
Debug.Assert(iDb >= 0);
#if !SQLITE_OMIT_AUTHORIZATION
if (sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab.zName, 0,
pParse.db.aDb[iDb].zName))
{
return;
}
#endif
/* Establish a read-lock on the table at the shared-cache level. */
sqlite3TableLock(pParse, iDb, pTab.tnum, 0, pTab.zName);
iIdxCur = pParse.nTab++;
for (pIdx = pTab.pIndex; pIdx != null; pIdx = pIdx.pNext)
{
KeyInfo pKey = sqlite3IndexKeyinfo(pParse, pIdx);
int regFields; /* Register block for building records */
int regRec; /* Register holding completed record */
int regTemp; /* Temporary use register */
int regCol; /* Content of a column from the table being analyzed */
int regRowid; /* Rowid for the inserted record */
int regF2;
/* Open a cursor to the index to be analyzed
*/
Debug.Assert(iDb == sqlite3SchemaToIndex(pParse.db, pIdx.pSchema));
nCol = pIdx.nColumn;
sqlite3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIdx.tnum, iDb,
pKey, P4_KEYINFO_HANDOFF);
#if SQLITE_DEBUG
VdbeComment(v, "%s", pIdx.zName);
#endif
regFields = iMem + nCol * 2;
regTemp = regRowid = regCol = regFields + 3;
regRec = regCol + 1;
if (regRec > pParse.nMem)
{
pParse.nMem = regRec;
}
/* Memory cells are used as follows:
**
** mem[iMem]: The total number of rows in the table.
** mem[iMem+1]: Number of distinct values in column 1
** ...
** mem[iMem+nCol]: Number of distinct values in column N
** mem[iMem+nCol+1] Last observed value of column 1
** ...
** mem[iMem+nCol+nCol]: Last observed value of column N
**
** Cells iMem through iMem+nCol are initialized to 0. The others
** are initialized to NULL.
*/
for (i = 0; i <= nCol; i++)
{
sqlite3VdbeAddOp2(v, OP_Integer, 0, iMem + i);
}
for (i = 0; i < nCol; i++)
{
sqlite3VdbeAddOp2(v, OP_Null, 0, iMem + nCol + i + 1);
}
/* Do the analysis.
*/
endOfLoop = sqlite3VdbeMakeLabel(v);
sqlite3VdbeAddOp2(v, OP_Rewind, iIdxCur, endOfLoop);
topOfLoop = sqlite3VdbeCurrentAddr(v);
sqlite3VdbeAddOp2(v, OP_AddImm, iMem, 1);
for (i = 0; i < nCol; i++)
{
sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regCol);
sqlite3VdbeAddOp3(v, OP_Ne, regCol, 0, iMem + nCol + i + 1);
/**** TODO: add collating sequence *****/
sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
}
sqlite3VdbeAddOp2(v, OP_Goto, 0, endOfLoop);
for (i = 0; i < nCol; i++)
{
sqlite3VdbeJumpHere(v, topOfLoop + 2 * (i + 1));
sqlite3VdbeAddOp2(v, OP_AddImm, iMem + i + 1, 1);
sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem + nCol + i + 1);
}
sqlite3VdbeResolveLabel(v, endOfLoop);
sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, topOfLoop);
sqlite3VdbeAddOp1(v, OP_Close, iIdxCur);
/* Store the results.
**
** The result is a single row of the sqlite_stat1 table. The first
** two columns are the names of the table and index. The third column
** is a string composed of a list of integer statistics about the
** index. The first integer in the list is the total number of entries
** in the index. There is one additional integer in the list for each
** column of the table. This additional integer is a guess of how many
** rows of the table the index will select. If D is the count of distinct
** values and K is the total number of rows, then the integer is computed
** as:
**
** I = (K+D-1)/D
**
** If K==0 then no entry is made into the sqlite_stat1 table.
** If K>0 then it is always the case the D>0 so division by zero
** is never possible.
*/
addr = sqlite3VdbeAddOp1(v, OP_IfNot, iMem);
sqlite3VdbeAddOp4(v, OP_String8, 0, regFields, 0, pTab.zName, 0);
sqlite3VdbeAddOp4(v, OP_String8, 0, regFields + 1, 0, pIdx.zName, 0);
regF2 = regFields + 2;
sqlite3VdbeAddOp2(v, OP_SCopy, iMem, regF2);
for (i = 0; i < nCol; i++)
{
sqlite3VdbeAddOp4(v, OP_String8, 0, regTemp, 0, ' ', 0);
sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regF2, regF2);
sqlite3VdbeAddOp3(v, OP_Add, iMem, iMem + i + 1, regTemp);
sqlite3VdbeAddOp2(v, OP_AddImm, regTemp, -1);
sqlite3VdbeAddOp3(v, OP_Divide, iMem + i + 1, regTemp, regTemp);
sqlite3VdbeAddOp1(v, OP_ToInt, regTemp);
sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regF2, regF2);
}
sqlite3VdbeAddOp4(v, OP_MakeRecord, regFields, 3, regRec, new byte[] { (byte)'a', (byte)'a', (byte)'a' }, 0);
sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regRowid);
sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regRowid);
sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
sqlite3VdbeJumpHere(v, addr);
}
}
/*
** Generate code for scalar subqueries used as a subquery expression, EXISTS,
** or IN operators. Examples:
**
** (SELECT a FROM b) -- subquery
** EXISTS (SELECT a FROM b) -- EXISTS subquery
** x IN (4,5,11) -- IN operator with list on right-hand side
** x IN (SELECT a FROM b) -- IN operator with subquery on the right
**
** The pExpr parameter describes the expression that contains the IN
** operator or subquery.
**
** If parameter isRowid is non-zero, then expression pExpr is guaranteed
** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
** to some integer key column of a table B-Tree. In this case, use an
** intkey B-Tree to store the set of IN(...) values instead of the usual
** (slower) variable length keys B-Tree.
**
** If rMayHaveNull is non-zero, that means that the operation is an IN
** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
** Furthermore, the IN is in a WHERE clause and that we really want
** to iterate over the RHS of the IN operator in order to quickly locate
** all corresponding LHS elements. All this routine does is initialize
** the register given by rMayHaveNull to NULL. Calling routines will take
** care of changing this register value to non-NULL if the RHS is NULL-free.
**
** If rMayHaveNull is zero, that means that the subquery is being used
** for membership testing only. There is no need to initialize any
** registers to indicate the presense or absence of NULLs on the RHS.
**
** For a SELECT or EXISTS operator, return the register that holds the
** result. For IN operators or if an error occurs, the return value is 0.
*/
#if !SQLITE_OMIT_SUBQUERY
static int sqlite3CodeSubselect(
Parse pParse, /* Parsing context */
Expr pExpr, /* The IN, SELECT, or EXISTS operator */
int rMayHaveNull, /* Register that records whether NULLs exist in RHS */
bool isRowid /* If true, LHS of IN operator is a rowid */
)
{
int testAddr = 0; /* One-time test address */
int rReg = 0; /* Register storing resulting */
Vdbe v = sqlite3GetVdbe( pParse );
if ( NEVER( v == null ) )
return 0;
sqlite3ExprCachePush( pParse );
/* This code must be run in its entirety every time it is encountered
** if any of the following is true:
**
** * The right-hand side is a correlated subquery
** * The right-hand side is an expression list containing variables
** * We are inside a trigger
**
** If all of the above are false, then we can run this code just once
** save the results, and reuse the same result on subsequent invocations.
*/
if ( !ExprHasAnyProperty( pExpr, EP_VarSelect ) && null == pParse.pTriggerTab )
{
int mem = ++pParse.nMem;
sqlite3VdbeAddOp1( v, OP_If, mem );
testAddr = sqlite3VdbeAddOp2( v, OP_Integer, 1, mem );
Debug.Assert( testAddr > 0 /* || pParse.db.mallocFailed != 0 */ );
}
#if !SQLITE_OMIT_EXPLAIN
if ( pParse.explain == 2 )
{
string zMsg = sqlite3MPrintf(
pParse.db, "EXECUTE %s%s SUBQUERY %d", testAddr != 0 ? "" : "CORRELATED ",
pExpr.op == TK_IN ? "LIST" : "SCALAR", pParse.iNextSelectId
);
sqlite3VdbeAddOp4( v, OP_Explain, pParse.iSelectId, 0, 0, zMsg, P4_DYNAMIC );
}
#endif
switch ( pExpr.op )
{
case TK_IN:
{
char affinity; /* Affinity of the LHS of the IN */
KeyInfo keyInfo; /* Keyinfo for the generated table */
int addr; /* Address of OP_OpenEphemeral instruction */
Expr pLeft = pExpr.pLeft; /* the LHS of the IN operator */
if ( rMayHaveNull != 0 )
{
sqlite3VdbeAddOp2( v, OP_Null, 0, rMayHaveNull );
}
affinity = sqlite3ExprAffinity( pLeft );
/* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
** expression it is handled the same way. An ephemeral table is
** filled with single-field index keys representing the results
** from the SELECT or the <exprlist>.
**
** If the 'x' expression is a column value, or the SELECT...
** statement returns a column value, then the affinity of that
** column is used to build the index keys. If both 'x' and the
** SELECT... statement are columns, then numeric affinity is used
** if either column has NUMERIC or INTEGER affinity. If neither
** 'x' nor the SELECT... statement are columns, then numeric affinity
** is used.
*/
pExpr.iTable = pParse.nTab++;
addr = sqlite3VdbeAddOp2( v, OP_OpenEphemeral, (int)pExpr.iTable, !isRowid );
if ( rMayHaveNull == 0 )
sqlite3VdbeChangeP5( v, BTREE_UNORDERED );
keyInfo = new KeyInfo();// memset( &keyInfo, 0, sizeof(keyInfo ));
keyInfo.nField = 1;
if ( ExprHasProperty( pExpr, EP_xIsSelect ) )
{
/* Case 1: expr IN (SELECT ...)
**
** Generate code to write the results of the select into the temporary
** table allocated and opened above.
*/
SelectDest dest = new SelectDest();
ExprList pEList;
Debug.Assert( !isRowid );
sqlite3SelectDestInit( dest, SRT_Set, pExpr.iTable );
dest.affinity = (char)affinity;
Debug.Assert( ( pExpr.iTable & 0x0000FFFF ) == pExpr.iTable );
pExpr.x.pSelect.iLimit = 0;
if ( sqlite3Select( pParse, pExpr.x.pSelect, ref dest ) != 0 )
{
return 0;
}
pEList = pExpr.x.pSelect.pEList;
if ( ALWAYS( pEList != null ) && pEList.nExpr > 0 )
{
keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq( pParse, pExpr.pLeft,
pEList.a[0].pExpr );
}
}
else if ( ALWAYS( pExpr.x.pList != null ) )
{
/* Case 2: expr IN (exprlist)
**
** For each expression, build an index key from the evaluation and
** store it in the temporary table. If <expr> is a column, then use
** that columns affinity when building index keys. If <expr> is not
** a column, use numeric affinity.
*/
int i;
ExprList pList = pExpr.x.pList;
ExprList_item pItem;
int r1, r2, r3;
if ( affinity == '\0' )
{
affinity = SQLITE_AFF_NONE;
}
keyInfo.aColl[0] = sqlite3ExprCollSeq( pParse, pExpr.pLeft );
/* Loop through each expression in <exprlist>. */
r1 = sqlite3GetTempReg( pParse );
r2 = sqlite3GetTempReg( pParse );
sqlite3VdbeAddOp2( v, OP_Null, 0, r2 );
for ( i = 0; i < pList.nExpr; i++ )
{//, pItem++){
pItem = pList.a[i];
Expr pE2 = pItem.pExpr;
int iValToIns = 0;
/* If the expression is not constant then we will need to
** disable the test that was generated above that makes sure
** this code only executes once. Because for a non-constant
** expression we need to rerun this code each time.
*/
if ( testAddr != 0 && sqlite3ExprIsConstant( pE2 ) == 0 )
{
sqlite3VdbeChangeToNoop( v, testAddr - 1, 2 );
testAddr = 0;
}
/* Evaluate the expression and insert it into the temp table */
if ( isRowid && sqlite3ExprIsInteger( pE2, ref iValToIns ) != 0 )
{
sqlite3VdbeAddOp3( v, OP_InsertInt, pExpr.iTable, r2, iValToIns );
}
else
{
r3 = sqlite3ExprCodeTarget( pParse, pE2, r1 );
if ( isRowid )
{
sqlite3VdbeAddOp2( v, OP_MustBeInt, r3,
sqlite3VdbeCurrentAddr( v ) + 2 );
sqlite3VdbeAddOp3( v, OP_Insert, pExpr.iTable, r2, r3 );
}
else
{
sqlite3VdbeAddOp4( v, OP_MakeRecord, r3, 1, r2, affinity, 1 );
sqlite3ExprCacheAffinityChange( pParse, r3, 1 );
sqlite3VdbeAddOp2( v, OP_IdxInsert, pExpr.iTable, r2 );
}
}
}
sqlite3ReleaseTempReg( pParse, r1 );
sqlite3ReleaseTempReg( pParse, r2 );
}
if ( !isRowid )
{
sqlite3VdbeChangeP4( v, addr, keyInfo, P4_KEYINFO );
}
break;
}
case TK_EXISTS:
case TK_SELECT:
default:
{
/* If this has to be a scalar SELECT. Generate code to put the
** value of this select in a memory cell and record the number
** of the memory cell in iColumn. If this is an EXISTS, write
** an integer 0 (not exists) or 1 (exists) into a memory cell
** and record that memory cell in iColumn.
*/
Select pSel; /* SELECT statement to encode */
SelectDest dest = new SelectDest(); /* How to deal with SELECt result */
testcase( pExpr.op == TK_EXISTS );
testcase( pExpr.op == TK_SELECT );
Debug.Assert( pExpr.op == TK_EXISTS || pExpr.op == TK_SELECT );
Debug.Assert( ExprHasProperty( pExpr, EP_xIsSelect ) );
pSel = pExpr.x.pSelect;
sqlite3SelectDestInit( dest, 0, ++pParse.nMem );
if ( pExpr.op == TK_SELECT )
{
dest.eDest = SRT_Mem;
sqlite3VdbeAddOp2( v, OP_Null, 0, dest.iParm );
#if SQLITE_DEBUG
VdbeComment( v, "Init subquery result" );
#endif
}
else
{
dest.eDest = SRT_Exists;
sqlite3VdbeAddOp2( v, OP_Integer, 0, dest.iParm );
#if SQLITE_DEBUG
VdbeComment( v, "Init EXISTS result" );
#endif
}
sqlite3ExprDelete( pParse.db, ref pSel.pLimit );
pSel.pLimit = sqlite3PExpr( pParse, TK_INTEGER, null, null, sqlite3IntTokens[1] );
pSel.iLimit = 0;
if ( sqlite3Select( pParse, pSel, ref dest ) != 0 )
{
return 0;
}
rReg = dest.iParm;
ExprSetIrreducible( pExpr );
break;
}
}
if ( testAddr != 0 )
{
sqlite3VdbeJumpHere( v, testAddr - 1 );
}
sqlite3ExprCachePop( pParse, 1 );
return rReg;
}
public virtual void Run(IConsoleWindow window)
{
_statusList.Enqueue("Press ? for Help.");
IsRunning = true;
new SpawnEnemiesCommand().Execute(this);
new SpawnItemsCommand().Execute(this);
while (IsRunning)
{
Console.CursorVisible = false;
var mapWidth = window.Area.Width * 2 / 3;
var mapHeight = window.Area.Height - 1;
var mapArea = window.CreateConsoleArea(new Area(new Position(0, 1), new Size(mapWidth, mapHeight)));
mapArea.Clear();
_renderer.Render(this, mapArea);
var playerArea = window.CreateConsoleArea(new Area(
new Position(mapWidth, 1),
new Size(window.Area.Width - mapWidth, mapHeight)));
playerArea.Clear();
_playerRenderer.Render(this, playerArea);
var statusArea = window.CreateConsoleArea(new Area(Position.Zero, new Size(window.Area.Width, 1)));
statusArea.Clear();
while (_statusList.Any())
{
statusArea.Clear();
var status = _statusList.Dequeue();
if (_statusList.Any())
{
status += " <more>";
}
statusArea.Write(Position.Zero, status);
window.Render();
if (_statusList.Any())
{
KeyInfo.GetInput();
}
}
window.Render();
_commandFactory.Execute(this, KeyInfo.GetInput());
if (_characters.Count != 0)
{
continue;
}
IsRunning = false;
window.Clear();
window.Write(Position.Zero, "All your enemies are dead. Congratulations!");
window.Write(new Position(0, 1), "You are the only one left on earth.");
window.Render();
}
}
/*
** Code an output subroutine for a coroutine implementation of a
** SELECT statment.
**
** The data to be output is contained in pIn.iMem. There are
** pIn.nMem columns to be output. pDest is where the output should
** be sent.
**
** regReturn is the number of the register holding the subroutine
** return address.
**
** If regPrev>0 then it is the first register in a vector that
** records the previous output. mem[regPrev] is a flag that is false
** if there has been no previous output. If regPrev>0 then code is
** generated to suppress duplicates. pKeyInfo is used for comparing
** keys.
**
** If the LIMIT found in p.iLimit is reached, jump immediately to
** iBreak.
*/
static int generateOutputSubroutine(
Parse pParse, /* Parsing context */
Select p, /* The SELECT statement */
SelectDest pIn, /* Coroutine supplying data */
SelectDest pDest, /* Where to send the data */
int regReturn, /* The return address register */
int regPrev, /* Previous result register. No uniqueness if 0 */
KeyInfo pKeyInfo, /* For comparing with previous entry */
int p4type, /* The p4 type for pKeyInfo */
int iBreak /* Jump here if we hit the LIMIT */
)
{
Vdbe v = pParse.pVdbe;
int iContinue;
int addr;
addr = sqlite3VdbeCurrentAddr( v );
iContinue = sqlite3VdbeMakeLabel( v );
/* Suppress duplicates for UNION, EXCEPT, and INTERSECT
*/
if ( regPrev != 0 )
{
int j1, j2;
j1 = sqlite3VdbeAddOp1( v, OP_IfNot, regPrev );
j2 = sqlite3VdbeAddOp4( v, OP_Compare, pIn.iMem, regPrev + 1, pIn.nMem,
pKeyInfo, p4type );
sqlite3VdbeAddOp3( v, OP_Jump, j2 + 2, iContinue, j2 + 2 );
sqlite3VdbeJumpHere( v, j1 );
sqlite3ExprCodeCopy( pParse, pIn.iMem, regPrev + 1, pIn.nMem );
sqlite3VdbeAddOp2( v, OP_Integer, 1, regPrev );
}
//if ( pParse.db.mallocFailed != 0 ) return 0;
/* Suppress the the first OFFSET entries if there is an OFFSET clause
*/
codeOffset( v, p, iContinue );
switch ( pDest.eDest )
{
/* Store the result as data using a unique key.
*/
case SRT_Table:
case SRT_EphemTab:
{
int r1 = sqlite3GetTempReg( pParse );
int r2 = sqlite3GetTempReg( pParse );
testcase( pDest.eDest == SRT_Table );
testcase( pDest.eDest == SRT_EphemTab );
sqlite3VdbeAddOp3( v, OP_MakeRecord, pIn.iMem, pIn.nMem, r1 );
sqlite3VdbeAddOp2( v, OP_NewRowid, pDest.iParm, r2 );
sqlite3VdbeAddOp3( v, OP_Insert, pDest.iParm, r1, r2 );
sqlite3VdbeChangeP5( v, OPFLAG_APPEND );
sqlite3ReleaseTempReg( pParse, r2 );
sqlite3ReleaseTempReg( pParse, r1 );
break;
}
#if !SQLITE_OMIT_SUBQUERY
/* If we are creating a set for an "expr IN (SELECT ...)" construct,
** then there should be a single item on the stack. Write this
** item into the set table with bogus data.
*/
case SRT_Set:
{
int r1;
Debug.Assert( pIn.nMem == 1 );
p.affinity =
sqlite3CompareAffinity( p.pEList.a[0].pExpr, pDest.affinity );
r1 = sqlite3GetTempReg( pParse );
sqlite3VdbeAddOp4( v, OP_MakeRecord, pIn.iMem, 1, r1, p.affinity, 1 );
sqlite3ExprCacheAffinityChange( pParse, pIn.iMem, 1 );
sqlite3VdbeAddOp2( v, OP_IdxInsert, pDest.iParm, r1 );
sqlite3ReleaseTempReg( pParse, r1 );
break;
}
#if FALSE //* Never occurs on an ORDER BY query */
/* If any row exist in the result set, record that fact and abort.
*/
case SRT_Exists: {
sqlite3VdbeAddOp2(v, OP_Integer, 1, pDest.iParm);
/* The LIMIT clause will terminate the loop for us */
break;
}
#endif
/* If this is a scalar select that is part of an expression, then
** store the results in the appropriate memory cell and break out
** of the scan loop.
*/
case SRT_Mem:
{
Debug.Assert( pIn.nMem == 1 );
sqlite3ExprCodeMove( pParse, pIn.iMem, pDest.iParm, 1 );
/* The LIMIT clause will jump out of the loop for us */
break;
}
#endif //* #if !SQLITE_OMIT_SUBQUERY */
/* The results are stored in a sequence of registers
** starting at pDest.iMem. Then the co-routine yields.
*/
case SRT_Coroutine:
{
if ( pDest.iMem == 0 )
{
pDest.iMem = sqlite3GetTempRange( pParse, pIn.nMem );
pDest.nMem = pIn.nMem;
}
sqlite3ExprCodeMove( pParse, pIn.iMem, pDest.iMem, pDest.nMem );
sqlite3VdbeAddOp1( v, OP_Yield, pDest.iParm );
break;
}
/* If none of the above, then the result destination must be
** SRT_Output. This routine is never called with any other
** destination other than the ones handled above or SRT_Output.
**
** For SRT_Output, results are stored in a sequence of registers.
** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
** return the next row of result.
*/
default:
{
Debug.Assert( pDest.eDest == SRT_Output );
sqlite3VdbeAddOp2( v, OP_ResultRow, pIn.iMem, pIn.nMem );
sqlite3ExprCacheAffinityChange( pParse, pIn.iMem, pIn.nMem );
break;
}
}
/* Jump to the end of the loop if the LIMIT is reached.
*/
if ( p.iLimit != 0 )
{
sqlite3VdbeAddOp3( v, OP_IfZero, p.iLimit, iBreak, -1 );
}
/* Generate the subroutine return
*/
sqlite3VdbeResolveLabel( v, iContinue );
sqlite3VdbeAddOp1( v, OP_Return, regReturn );
return addr;
}
public XmlDocument SignXml(XmlDocument xmlDoc, byte[] pfx, RSA rsaKey, string claveCert)
{
// Check arguments.
if (xmlDoc == null)
{
throw new ArgumentException("xmlDoc");
}
if (rsaKey == null)
{
throw new ArgumentException("Key");
}
X509Certificate2 cert = new X509Certificate2(pfx, claveCert);
RSACryptoServiceProvider Key = cert.PrivateKey as RSACryptoServiceProvider;
// Create a SignedXml object.
SignedXml signedXml = new SignedXml(xmlDoc)
{
SigningKey = Key
};
// Add the key to the SignedXml document.
//signedXml.SigningKey = rsaKey;
// Create a reference to be signed.
Reference reference = new Reference();
reference.Uri = "";
// Add an enveloped transformation to the reference.
XmlDsigEnvelopedSignatureTransform env = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(env);
/* */
KeyInfoX509Data kdata = new KeyInfoX509Data(cert);
kdata.AddIssuerSerial(cert.Issuer, cert.SerialNumber);
KeyInfo keyInfo = new KeyInfo();
keyInfo.AddClause(kdata);
signedXml.KeyInfo = keyInfo;
/* */
// Add the reference to the SignedXml object.
signedXml.AddReference(reference);
// Compute the signature.
signedXml.ComputeSignature();
/* 18.11.2016 - Se agrega prefijo ds a la firma digital */
// Add prefix "ds:" to signature
XmlElement signature = signedXml.GetXml();
SetPrefix("ds", signature);
// Load modified signature back
signedXml.LoadXml(signature);
// this is workaround for overcoming a bug in the library
signedXml.SignedInfo.References.Clear();
// Recompute the signature
signedXml.ComputeSignature();
string recomputedSignature = Convert.ToBase64String(signedXml.SignatureValue);
// Replace value of the signature with recomputed one
ReplaceSignature(signature, recomputedSignature);
// Append the signature to the XML document.
xmlDoc.DocumentElement.InsertAfter(xmlDoc.ImportNode(signature, true), xmlDoc.DocumentElement.FirstChild);
/* */
/*
* // Get the XML representation of the signature and save
* // it to an XmlElement object.
* XmlElement xmlDigitalSignature = signedXml.GetXml();
*
* // Append the element to the XML document.
* xmlDoc.DocumentElement.AppendChild(xmlDoc.ImportNode(xmlDigitalSignature, true));
*/
return(xmlDoc);
}
/*
** Given an expression list, generate a KeyInfo structure that records
** the collating sequence for each expression in that expression list.
**
** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
** KeyInfo structure is appropriate for initializing a virtual index to
** implement that clause. If the ExprList is the result set of a SELECT
** then the KeyInfo structure is appropriate for initializing a virtual
** index to implement a DISTINCT test.
**
** Space to hold the KeyInfo structure is obtain from malloc. The calling
** function is responsible for seeing that this structure is eventually
** freed. Add the KeyInfo structure to the P4 field of an opcode using
** P4_KEYINFO_HANDOFF is the usual way of dealing with this.
*/
static KeyInfo keyInfoFromExprList( Parse pParse, ExprList pList )
{
sqlite3 db = pParse.db;
int nExpr;
KeyInfo pInfo;
ExprList_item pItem;
int i;
nExpr = pList.nExpr;
pInfo = new KeyInfo();//sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(CollSeq*.Length+1) );
if ( pInfo != null )
{
pInfo.aSortOrder = new byte[nExpr];// pInfo.aColl[nExpr];
pInfo.aColl = new CollSeq[nExpr];
pInfo.nField = (u16)nExpr;
pInfo.enc = db.aDbStatic[0].pSchema.enc;// ENC(db);
pInfo.db = db;
for ( i = 0; i < nExpr; i++ )
{//, pItem++){
pItem = pList.a[i];
CollSeq pColl;
pColl = sqlite3ExprCollSeq( pParse, pItem.pExpr );
if ( pColl == null )
{
pColl = db.pDfltColl;
}
pInfo.aColl[i] = pColl;
pInfo.aSortOrder[i] = (byte)pItem.sortOrder;
}
}
return pInfo;
}
/* TIA 102.AACD-A 3.8.7 */
public List <RspKeyInfo> ViewKeyInfo()
{
List <RspKeyInfo> result = new List <RspKeyInfo>();
Begin();
try
{
bool more = true;
int marker = 0;
while (more)
{
InventoryCommandListActiveKeys commandKmmBody = new InventoryCommandListActiveKeys();
commandKmmBody.InventoryMarker = marker;
commandKmmBody.MaxKeysRequested = 78;
KmmBody responseKmmBody = TxRxKmm(commandKmmBody);
if (responseKmmBody is InventoryResponseListActiveKeys)
{
InventoryResponseListActiveKeys kmm = responseKmmBody as InventoryResponseListActiveKeys;
marker = kmm.InventoryMarker;
Logger.Debug("inventory marker: {0}", marker);
if (marker == 0)
{
more = false;
}
Logger.Debug("number of keys returned: {0}", kmm.Keys.Count);
for (int i = 0; i < kmm.Keys.Count; i++)
{
KeyInfo info = kmm.Keys[i];
Logger.Debug("* key index {0} *", i);
Logger.Debug("keyset id: {0} (dec), {0:X} (hex)", info.KeySetId);
Logger.Debug("sln: {0} (dec), {0:X} (hex)", info.SLN);
Logger.Debug("algorithm id: {0} (dec), {0:X} (hex)", info.AlgorithmId);
Logger.Debug("key id: {0} (dec), {0:X} (hex)", info.KeyId);
RspKeyInfo res = new RspKeyInfo();
res.KeysetId = info.KeySetId;
res.Sln = info.SLN;
res.AlgorithmId = info.AlgorithmId;
res.KeyId = info.KeyId;
result.Add(res);
}
}
else if (responseKmmBody is NegativeAcknowledgment)
{
NegativeAcknowledgment kmm = responseKmmBody as NegativeAcknowledgment;
string statusDescr = OperationStatusExtensions.ToStatusString(kmm.Status);
string statusReason = OperationStatusExtensions.ToReasonString(kmm.Status);
throw new Exception(string.Format("received negative acknowledgment{0}status: {1} (0x{2:X2}){0}{3}", Environment.NewLine, statusDescr, kmm.Status, statusReason));
}
else
{
throw new Exception("unexpected kmm");
}
}
}
catch
{
End();
throw;
}
End();
return(result);
}
