diff -Nru mysql-dfsg-5.0-5.0.51a/debian/changelog mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/changelog --- mysql-dfsg-5.0-5.0.51a/debian/changelog 2009-08-04 17:40:20.000000000 +0000 +++ mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/changelog 2009-08-04 14:54:03.000000000 +0000 @@ -1,3 +1,14 @@ +mysql-dfsg-5.0 (5.0.51a-3ubuntu5-sphinx1) hardy; urgency=low + + * new patch: 92_ssl_test_cert.dpatch (LP: #323755). + Patch by Adreas Olsson + * new patch: 93_sphinxse.dpatch: + dpatch version of the SphinxSE patch, originally for mysql 5.0.37. + * new patch: 93_debianupstream_reallyfix.dpatch: + Really remove references to upstream debian files. + + -- Devendra Gera Tue, 04 Aug 2009 14:53:03 +0000 + mysql-dfsg-5.0 (5.0.51a-3ubuntu5) hardy; urgency=low * debian/patches/59-fix-mysql-replication-logs.dpatch: diff -Nru /tmp/4LVtUT6EYc/mysql-dfsg-5.0-5.0.51a/debian/patches/00list /tmp/BTg1zmEllB/mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/patches/00list --- mysql-dfsg-5.0-5.0.51a/debian/patches/00list 2009-08-04 17:40:20.000000000 +0000 +++ mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/patches/00list 2009-08-04 14:49:34.000000000 +0000 @@ -14,6 +14,7 @@ 55_testsuite-2008.dpatch 56-mysqlhotcopy-invalid-dbtable.dpatch 57-fix-mysqlslowdump-config.dpatch +92_ssl_test_cert.dpatch 58-disable-ndb-backup-print.dpatch 59-fix-mysql-replication-logs.dpatch #60_raise-max-keylength.dpatch @@ -22,3 +23,5 @@ 90_upstreamdebiandir.dpatch 91_SECURITY_CVE-2007-5925.dpatch 92_fix_order_by32202.dpatch +93_sphinxse.dpatch +93_debianupstream_reallyfix.dpatch diff -Nru /tmp/4LVtUT6EYc/mysql-dfsg-5.0-5.0.51a/debian/patches/92_ssl_test_cert.dpatch /tmp/BTg1zmEllB/mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/patches/92_ssl_test_cert.dpatch --- mysql-dfsg-5.0-5.0.51a/debian/patches/92_ssl_test_cert.dpatch 1970-01-01 00:00:00.000000000 +0000 +++ mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/patches/92_ssl_test_cert.dpatch 2009-08-04 14:49:34.000000000 +0000 @@ -0,0 +1,720 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 92_ssl_test_cert.dpatch by +## +## All lines beginning with `## DP:' are a description of the patch. +## DP: No description. + +@DPATCH@ +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/r/openssl_1.result mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/r/openssl_1.result +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/r/openssl_1.result 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/r/openssl_1.result 2009-02-02 23:46:47.000000000 +0100 +@@ -3,8 +3,8 @@ + insert into t1 values (5); + grant select on test.* to ssl_user1@localhost require SSL; + grant select on test.* to ssl_user2@localhost require cipher "DHE-RSA-AES256-SHA"; +-grant select on test.* to ssl_user3@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com"; +-grant select on test.* to ssl_user4@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com" ISSUER "/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB"; ++grant select on test.* to ssl_user3@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "/C=SE/ST=Uppsala/O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com"; ++grant select on test.* to ssl_user4@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "/C=SE/ST=Uppsala/O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com" ISSUER "/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB"; + grant select on test.* to ssl_user5@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "xxx"; + flush privileges; + connect(localhost,ssl_user5,,test,MASTER_PORT,MASTER_SOCKET); +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/cacert.pem mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/cacert.pem +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/cacert.pem 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/cacert.pem 2009-02-02 23:46:47.000000000 +0100 +@@ -1,17 +1,17 @@ + -----BEGIN CERTIFICATE----- +-MIICrTCCAhagAwIBAgIJAIAO/Ybiptv1MA0GCSqGSIb3DQEBBAUAMEQxCzAJBgNV ++MIICrTCCAhagAwIBAgIJAJXpePU0UOTVMA0GCSqGSIb3DQEBBQUAMEQxCzAJBgNV + BAYTAlNFMRAwDgYDVQQIEwdVcHBzYWxhMRAwDgYDVQQHEwdVcHBzYWxhMREwDwYD +-VQQKEwhNeVNRTCBBQjAeFw0wNjA1MDMwODQ4NTRaFw0wOTAxMjcwODQ4NTRaMEQx ++VQQKEwhNeVNRTCBBQjAeFw0wOTAxMjgxMDQ5NDZaFw0xNDAxMjcxMDQ5NDZaMEQx + CzAJBgNVBAYTAlNFMRAwDgYDVQQIEwdVcHBzYWxhMRAwDgYDVQQHEwdVcHBzYWxh + MREwDwYDVQQKEwhNeVNRTCBBQjCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA +-+C46EQl1u7tQ6gb9eqc8V079gr8YmDPCEqtjO8bCIbchpjOpDITx0WZz36Sn9E72 +-GPJwNip4FxLaPRIA3xNQHM5cE5U53qznlRx1Fc4O3hcWCvyCqNDl/vzPAh3pI6Bl +-Ku9hfHXpp93W812smVPe9haShEXGgbEPYGzvOfVdu/MCAwEAAaOBpjCBozAdBgNV +-HQ4EFgQUjIy/6OCTmqtPHBFha6/qzVk3yTcwdAYDVR0jBG0wa4AUjIy/6OCTmqtP +-HBFha6/qzVk3yTehSKRGMEQxCzAJBgNVBAYTAlNFMRAwDgYDVQQIEwdVcHBzYWxh +-MRAwDgYDVQQHEwdVcHBzYWxhMREwDwYDVQQKEwhNeVNRTCBBQoIJAIAO/Ybiptv1 +-MAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEEBQADgYEA8lD9zyB820Oq1aj7ZafX +-De/hbdt9RIl2tzgw2K3r1KZGdXJVL0vSt5fZ51Nq9lg7OPJy3iXf+caBJEp0IJpB +-uf4Gfr6zfXw+UlY6ZthRtHQHoXKcbskECjH5/ps/Uaa+dpVQ9O+Ii1rPzmgo6ztM +-s+xZ46ESBt4WiHXm8kwbU9Y= ++4XQHAe5R1+TXC8noZtWf+d5E0v1C59FWpn9SWEUCBjE5UiIwuJvi4Y+7xWGOXLAI ++/JzJx5gNXLBiTsE/zh0uX9fKlajLhxB0GN+QU0ZlpQ1BeYipEcNXeI/7cT499f6v ++XWabnTflivdCgHSWUOQ20/Lzs6kP6/e6OoZd/DPSjPECAwEAAaOBpjCBozAdBgNV ++HQ4EFgQU8uLqVWWkmuKsnZf1RWz294wRrd8wdAYDVR0jBG0wa4AU8uLqVWWkmuKs ++nZf1RWz294wRrd+hSKRGMEQxCzAJBgNVBAYTAlNFMRAwDgYDVQQIEwdVcHBzYWxh ++MRAwDgYDVQQHEwdVcHBzYWxhMREwDwYDVQQKEwhNeVNRTCBBQoIJAJXpePU0UOTV ++MAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAMMTE5sDN+Z0ZlV7KvH3g ++6+aKvql8dTpRT3hYukeQlWua0nq74WPGVw0c4e/M/vbiMwmJcCYpB9pd4+dHqzSw ++aPyoenjY6UF8n7B4quWy3SIUk2LSHeJLW+kzJn2afN9gvipFhdVh/uU2TIyLGOur ++Z/vmJX2W7hF1uqPnbfa8Lrw= + -----END CERTIFICATE----- +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/client-cert.pem mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/client-cert.pem +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/client-cert.pem 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/client-cert.pem 2009-02-02 23:46:47.000000000 +0100 +@@ -1,42 +1,55 @@ + Certificate: + Data: +- Version: 1 (0x0) +- Serial Number: 1 (0x1) +- Signature Algorithm: md5WithRSAEncryption ++ Version: 3 (0x2) ++ Serial Number: 3 (0x3) ++ Signature Algorithm: sha1WithRSAEncryption + Issuer: C=SE, ST=Uppsala, L=Uppsala, O=MySQL AB + Validity +- Not Before: May 3 08:55:39 2006 GMT +- Not After : Jan 27 08:55:39 2009 GMT +- Subject: C=SE, ST=Uppsala, L=Uppsala, O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com ++ Not Before: Jan 28 11:04:39 2009 GMT ++ Not After : Jan 28 11:04:39 2010 GMT ++ Subject: C=SE, ST=Uppsala, O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com + Subject Public Key Info: + Public Key Algorithm: rsaEncryption + RSA Public Key: (512 bit) + Modulus (512 bit): +- 00:d8:db:68:28:49:84:4d:d6:0f:5c:bc:3d:9a:ab: +- 70:d5:3e:f5:b5:17:ba:ef:e1:f8:87:54:30:22:1f: +- 81:07:bf:f9:24:7f:8a:54:10:e9:5f:e6:99:50:04: +- d4:3b:55:a9:f1:52:ad:12:2b:5a:da:5c:be:8c:3e: +- 5b:9e:b0:5a:19 ++ 00:e1:52:30:2c:d9:be:64:28:91:5d:7a:fd:d9:e9: ++ 14:35:7a:d2:94:4e:91:46:e0:db:9f:6b:79:f4:4c: ++ ac:6e:07:61:34:86:74:62:a7:a8:44:af:fa:87:87: ++ a8:7d:42:61:ff:ab:50:d4:7b:bf:75:fa:d5:d5:b3: ++ 74:fb:56:1e:37 + Exponent: 65537 (0x10001) +- Signature Algorithm: md5WithRSAEncryption +- 07:57:bf:07:92:c2:8e:86:24:6b:0a:bf:e5:31:21:44:c3:60: +- 02:a6:ac:9e:f7:db:7a:6e:fc:4f:d4:7b:54:18:80:47:d2:4a: +- 63:0e:e3:f8:af:6e:58:e3:97:5a:2b:82:5d:76:20:d1:33:a0: +- f5:43:a1:d1:51:f4:ca:c8:b3:1a:66:4e:0e:55:df:d2:e8:fa: +- 83:18:42:f5:ec:66:40:f0:39:e8:f9:d7:cf:f6:dd:e4:7b:69: +- dd:0c:92:d8:52:95:43:6f:29:3d:f0:8d:4c:dd:52:ea:6b:a0: +- 39:0f:dc:59:a7:5c:37:6b:8b:05:44:b7:69:ea:a3:58:e0:4e: +- ce:d6 ++ X509v3 extensions: ++ X509v3 Basic Constraints: ++ CA:FALSE ++ X509v3 Subject Key Identifier: ++ 58:30:B5:9B:2C:05:94:06:BA:3D:3C:F0:B2:CD:1D:67:65:E3:7F:85 ++ X509v3 Authority Key Identifier: ++ keyid:F2:E2:EA:55:65:A4:9A:E2:AC:9D:97:F5:45:6C:F6:F7:8C:11:AD:DF ++ DirName:/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB ++ serial:95:E9:78:F5:34:50:E4:D5 ++ ++ Signature Algorithm: sha1WithRSAEncryption ++ 05:19:e3:13:14:fc:c5:28:bf:69:f8:00:b3:25:cb:bd:ca:9f: ++ 2f:4c:b3:a8:04:11:f0:74:27:bd:82:2c:b4:49:9b:a7:59:f0: ++ f7:87:d1:e0:ba:99:a2:fe:4b:1d:10:6f:e4:a2:b3:cd:7f:8b: ++ 68:31:46:ee:cd:9e:e2:47:e1:4c:fa:74:d1:e2:8b:cc:a0:4b: ++ a8:24:d1:a4:c3:6b:2a:c6:28:cd:41:e0:06:48:e6:cf:f2:3c: ++ ca:37:95:d7:29:64:6b:91:91:83:e7:ac:c8:0b:87:bc:da:a6: ++ aa:f1:44:43:c8:74:7b:15:26:91:2e:03:c4:71:50:6c:f8:68: ++ dc:8c + -----BEGIN CERTIFICATE----- +-MIIB5jCCAU8CAQEwDQYJKoZIhvcNAQEEBQAwRDELMAkGA1UEBhMCU0UxEDAOBgNV +-BAgTB1VwcHNhbGExEDAOBgNVBAcTB1VwcHNhbGExETAPBgNVBAoTCE15U1FMIEFC +-MB4XDTA2MDUwMzA4NTUzOVoXDTA5MDEyNzA4NTUzOVowdzELMAkGA1UEBhMCU0Ux +-EDAOBgNVBAgTB1VwcHNhbGExEDAOBgNVBAcTB1VwcHNhbGExETAPBgNVBAoTCE15 +-U1FMIEFCMTEwLwYJKoZIhvcNAQkBFiJhYnN0cmFjdC5teXNxbC5kZXZlbG9wZXJA +-bXlzcWwuY29tMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBANjbaChJhE3WD1y8PZqr +-cNU+9bUXuu/h+IdUMCIfgQe/+SR/ilQQ6V/mmVAE1DtVqfFSrRIrWtpcvow+W56w +-WhkCAwEAATANBgkqhkiG9w0BAQQFAAOBgQAHV78HksKOhiRrCr/lMSFEw2ACpqye +-99t6bvxP1HtUGIBH0kpjDuP4r25Y45daK4JddiDRM6D1Q6HRUfTKyLMaZk4OVd/S +-6PqDGEL17GZA8Dno+dfP9t3ke2ndDJLYUpVDbyk98I1M3VLqa6A5D9xZp1w3a4sF +-RLdp6qNY4E7O1g== ++MIICfzCCAeigAwIBAgIBAzANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJTRTEQ ++MA4GA1UECBMHVXBwc2FsYTEQMA4GA1UEBxMHVXBwc2FsYTERMA8GA1UEChMITXlT ++UUwgQUIwHhcNMDkwMTI4MTEwNDM5WhcNMTAwMTI4MTEwNDM5WjBlMQswCQYDVQQG ++EwJTRTEQMA4GA1UECBMHVXBwc2FsYTERMA8GA1UEChMITXlTUUwgQUIxMTAvBgkq ++hkiG9w0BCQEWImFic3RyYWN0Lm15c3FsLmRldmVsb3BlckBteXNxbC5jb20wXDAN ++BgkqhkiG9w0BAQEFAANLADBIAkEA4VIwLNm+ZCiRXXr92ekUNXrSlE6RRuDbn2t5 ++9EysbgdhNIZ0YqeoRK/6h4eofUJh/6tQ1Hu/dfrV1bN0+1YeNwIDAQABo4GjMIGg ++MAkGA1UdEwQCMAAwHQYDVR0OBBYEFFgwtZssBZQGuj088LLNHWdl43+FMHQGA1Ud ++IwRtMGuAFPLi6lVlpJrirJ2X9UVs9veMEa3foUikRjBEMQswCQYDVQQGEwJTRTEQ ++MA4GA1UECBMHVXBwc2FsYTEQMA4GA1UEBxMHVXBwc2FsYTERMA8GA1UEChMITXlT ++UUwgQUKCCQCV6Xj1NFDk1TANBgkqhkiG9w0BAQUFAAOBgQAFGeMTFPzFKL9p+ACz ++Jcu9yp8vTLOoBBHwdCe9giy0SZunWfD3h9Hgupmi/ksdEG/korPNf4toMUbuzZ7i ++R+FM+nTR4ovMoEuoJNGkw2sqxijNQeAGSObP8jzKN5XXKWRrkZGD56zIC4e82qaq ++8URDyHR7FSaRLgPEcVBs+GjcjA== + -----END CERTIFICATE----- +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/client-key.pem mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/client-key.pem +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/client-key.pem 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/client-key.pem 2009-02-02 23:46:47.000000000 +0100 +@@ -1,9 +1,9 @@ + -----BEGIN RSA PRIVATE KEY----- +-MIIBOgIBAAJBANjbaChJhE3WD1y8PZqrcNU+9bUXuu/h+IdUMCIfgQe/+SR/ilQQ +-6V/mmVAE1DtVqfFSrRIrWtpcvow+W56wWhkCAwEAAQJAK27WT6tZylUjQomZNQ89 +-TBiOEbUtBbqWklQ0R8FTkH9uKV+8KYQ+k+tMkoAEGFfChB0YfofNQ2KZYWWw4yOB +-WQIhAPXXDQt73aou10s+cmKM3C3WzLmIZtrvm9wNBXWDGxgTAiEA4dG4cXrZfa1M +-TTbjzNU1/Jf50/M8SvZDWMPQWxJ8oqMCIH6zBpYUkHlVCsBMvsbrsc4uFfTIx7mu +-I7WVQGr/1sbhAiBf4uFirjtztgZUMx5/d3k5DH80lG/hlLf8FQl/4lWx6QIhAPHw +-CXfPUbUFl4r/i9Br5+exGol50qX4F3aP5Sh5EnZT ++MIIBOQIBAAJBAOFSMCzZvmQokV16/dnpFDV60pROkUbg259refRMrG4HYTSGdGKn ++qESv+oeHqH1CYf+rUNR7v3X61dWzdPtWHjcCAwEAAQJAXYooM8ZlcuEgj+VKU1ee ++qyEFIMqJJxqcMk+E/nWCM96WxCP3zHNSrqNfSpI3ld7QzMwhdRz+gFLxT2gGNpIw ++MQIhAPxzM/lDihe67X3ADYtDl9ZjA8Pm430x9sXlcxI17tCZAiEA5H1SyFl4mUee ++9VnfSC2XGW7lwz72ZygfVX+b7tLWF08CIEh40gzW5MfXM+KLxdea+fXjyursV5ZT ++R6KcMiKiNQLRAiAcmHqlzFzFgisotai2Fc6VRkXHG7gmzOSvBJt1VjmpDQIge6jf ++2N7whTdvC4ferB+zUlgWQdyvx1c3T4gnt6PYdaY= + -----END RSA PRIVATE KEY----- +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server-cert-des.pem mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server-cert-des.pem +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server-cert-des.pem 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server-cert-des.pem 1970-01-01 01:00:00.000000000 +0100 +@@ -1,16 +0,0 @@ +------BEGIN CERTIFICATE----- +-MIICljCCAX4CAQEwDQYJKoZIhvcNAQEEBQAwUTELMAkGA1UEBhMCU0UxEDAOBgNV +-BAgTB1VwcHNhbGExETAPBgNVBAoTCE15U1FMIEFCMRAwDgYDVQQLEwdTdXBwb3J0 +-MQswCQYDVQQDEwJDQTAeFw0wNjA4MjgxMTA4NTlaFw0wOTA1MjQxMTA4NTlaMFUx +-CzAJBgNVBAYTAlNFMRAwDgYDVQQIEwdVcHBzYWxhMREwDwYDVQQKEwhNeVNRTCBB +-QjEQMA4GA1UECxMHU3VwcG9ydDEPMA0GA1UEAxMGc2VydmVyMIGfMA0GCSqGSIb3 +-DQEBAQUAA4GNADCBiQKBgQDEiOVZcWYzZe7I8xhhUwCzvmkZifAXeMTH+8XKGLHX +-NWF3FLduAmeAad9oOZgBKb+oWTdRDWXqwu6nYYUBfrUpaY27/wLkgWRgewL3LZnw +-W2FjhNsjx3gI2NK+Pix47q9d+a+5T4AW5+lK499l0K0k2cvyFdIerhDW8R0t8Uru +-twIDAQABMA0GCSqGSIb3DQEBBAUAA4IBAQC2LQcqLg52RbelWrKutlJ5E6rzugnJ +-ZAlbN9sM98O2xFiIGDA3tb5j9LAEjE0E+RqdptEYnvy9b3szhLYXtIILZTkClf9r +-Uwu1nUYPTyp+9ZYCa4fovOU5h1Ogv+9UZPds/LPDwWEn8K+lvscB4X57wJyuoEck +-1Mu41OA6h77181MydSdgZo0oquJDWhdCsYHXVFVs0F6naMm2uPMCTDiQVlhHJuTO +-VQMNIwxRFtvsv2tpsXsaP/8sT32d5CFebfxxSVnqQvJ4ZdIrphl6L43XU01rsEcE +-K8KYujZQ6SKws+HVcGqsr7TPgJfJE6D+5RazvvIQISPvx4eduebqzqdC +------END CERTIFICATE----- +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server-cert.pem mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server-cert.pem +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server-cert.pem 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server-cert.pem 2009-02-02 23:46:47.000000000 +0100 +@@ -1,42 +1,55 @@ + Certificate: + Data: +- Version: 1 (0x0) ++ Version: 3 (0x2) + Serial Number: 1 (0x1) +- Signature Algorithm: md5WithRSAEncryption ++ Signature Algorithm: sha1WithRSAEncryption + Issuer: C=SE, ST=Uppsala, L=Uppsala, O=MySQL AB + Validity +- Not Before: May 3 08:54:13 2006 GMT +- Not After : Jan 27 08:54:13 2009 GMT +- Subject: C=SE, ST=Uppsala, L=Uppsala, O=MySQL AB, CN=localhost/emailAddress=abstract.mysql.developer@mysql.com ++ Not Before: Jan 28 10:55:13 2009 GMT ++ Not After : Jan 28 10:55:13 2010 GMT ++ Subject: C=SE, ST=Uppsala, O=MySQL AB, CN=localhost/emailAddress=abstract.mysql.developer@mysql.com + Subject Public Key Info: + Public Key Algorithm: rsaEncryption + RSA Public Key: (512 bit) + Modulus (512 bit): +- 00:d9:fd:da:b3:fb:7c:e0:b0:03:be:97:c6:a4:36: +- ac:71:af:bb:2d:e5:84:ed:f3:8f:2b:eb:11:e5:aa: +- 66:ed:bf:62:6b:e3:ce:fa:80:ed:90:ff:b9:4a:39: +- 20:40:b6:f2:99:bf:2f:33:b5:f2:ec:3a:90:60:1d: +- 9e:94:7e:a4:1b ++ 00:b6:8f:e5:b7:b4:86:83:13:8a:f9:bf:63:cb:64: ++ 2d:b9:51:d1:de:ab:7b:45:1f:aa:b5:66:73:13:f9: ++ a6:07:d5:ba:7c:fa:92:bd:37:e2:ad:87:db:3e:b6: ++ 6a:12:64:f8:ee:17:e3:15:06:2f:a8:82:68:bf:57: ++ 8d:c3:04:98:27 + Exponent: 65537 (0x10001) +- Signature Algorithm: md5WithRSAEncryption +- de:5e:35:cd:7b:11:e6:7c:c5:7c:d6:27:4e:72:12:49:42:eb: +- 6f:2c:96:f3:f4:00:78:a7:4f:9f:2d:7b:d7:30:39:af:49:4d: +- df:b1:55:0d:30:be:23:6f:06:67:fd:dd:ba:98:66:36:c6:32: +- b7:ed:63:fc:aa:49:cd:4f:72:98:3b:13:0e:f6:28:d7:d4:eb: +- 04:6b:dc:e8:c7:04:80:92:e4:04:86:0b:ed:32:25:76:1d:a9: +- 5c:a9:2c:18:2c:bd:bc:15:ed:e1:76:96:4d:bb:0d:41:44:06: +- 2c:ad:45:bb:db:61:ad:17:11:cb:49:70:67:eb:c6:27:d3:91: +- c8:f2 ++ X509v3 extensions: ++ X509v3 Basic Constraints: ++ CA:FALSE ++ X509v3 Subject Key Identifier: ++ D9:9A:B8:5F:22:EA:04:10:C8:25:7D:82:57:E6:2E:FD:19:29:E7:DA ++ X509v3 Authority Key Identifier: ++ keyid:F2:E2:EA:55:65:A4:9A:E2:AC:9D:97:F5:45:6C:F6:F7:8C:11:AD:DF ++ DirName:/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB ++ serial:95:E9:78:F5:34:50:E4:D5 ++ ++ Signature Algorithm: sha1WithRSAEncryption ++ 54:07:2d:21:0b:a5:af:3b:58:23:32:5e:56:7f:ab:58:63:48: ++ 91:aa:38:90:89:16:f9:cc:bf:a4:0e:78:2b:9f:c5:1b:58:a6: ++ e6:08:8f:2e:ae:97:03:21:9b:f1:cd:c0:26:8f:1d:d7:28:27: ++ a0:8e:81:09:1b:1c:0f:c9:a5:41:3a:2d:44:3f:9c:fa:87:ff: ++ c8:4c:2b:44:f7:1b:c1:3e:4f:01:7f:e9:26:cc:9f:1c:06:b5: ++ 0b:27:d1:10:90:be:93:0c:9c:e7:b0:d1:ea:27:99:4e:06:14: ++ 0c:7a:e9:c1:52:c5:33:68:bc:61:0d:db:81:3b:57:48:57:bf: ++ 42:9a + -----BEGIN CERTIFICATE----- +-MIIB+zCCAWQCAQEwDQYJKoZIhvcNAQEEBQAwRDELMAkGA1UEBhMCU0UxEDAOBgNV +-BAgTB1VwcHNhbGExEDAOBgNVBAcTB1VwcHNhbGExETAPBgNVBAoTCE15U1FMIEFC +-MB4XDTA2MDUwMzA4NTQxM1oXDTA5MDEyNzA4NTQxM1owgYsxCzAJBgNVBAYTAlNF +-MRAwDgYDVQQIEwdVcHBzYWxhMRAwDgYDVQQHEwdVcHBzYWxhMREwDwYDVQQKEwhN +-eVNRTCBBQjESMBAGA1UEAxMJbG9jYWxob3N0MTEwLwYJKoZIhvcNAQkBFiJhYnN0 +-cmFjdC5teXNxbC5kZXZlbG9wZXJAbXlzcWwuY29tMFwwDQYJKoZIhvcNAQEBBQAD +-SwAwSAJBANn92rP7fOCwA76XxqQ2rHGvuy3lhO3zjyvrEeWqZu2/YmvjzvqA7ZD/ +-uUo5IEC28pm/LzO18uw6kGAdnpR+pBsCAwEAATANBgkqhkiG9w0BAQQFAAOBgQDe +-XjXNexHmfMV81idOchJJQutvLJbz9AB4p0+fLXvXMDmvSU3fsVUNML4jbwZn/d26 +-mGY2xjK37WP8qknNT3KYOxMO9ijX1OsEa9zoxwSAkuQEhgvtMiV2HalcqSwYLL28 +-Fe3hdpZNuw1BRAYsrUW722GtFxHLSXBn68Yn05HI8g== ++MIICkzCCAfygAwIBAgIBATANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJTRTEQ ++MA4GA1UECBMHVXBwc2FsYTEQMA4GA1UEBxMHVXBwc2FsYTERMA8GA1UEChMITXlT ++UUwgQUIwHhcNMDkwMTI4MTA1NTEzWhcNMTAwMTI4MTA1NTEzWjB5MQswCQYDVQQG ++EwJTRTEQMA4GA1UECBMHVXBwc2FsYTERMA8GA1UEChMITXlTUUwgQUIxEjAQBgNV ++BAMTCWxvY2FsaG9zdDExMC8GCSqGSIb3DQEJARYiYWJzdHJhY3QubXlzcWwuZGV2 ++ZWxvcGVyQG15c3FsLmNvbTBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQC2j+W3tIaD ++E4r5v2PLZC25UdHeq3tFH6q1ZnMT+aYH1bp8+pK9N+Kth9s+tmoSZPjuF+MVBi+o ++gmi/V43DBJgnAgMBAAGjgaMwgaAwCQYDVR0TBAIwADAdBgNVHQ4EFgQU2Zq4XyLq ++BBDIJX2CV+Yu/Rkp59owdAYDVR0jBG0wa4AU8uLqVWWkmuKsnZf1RWz294wRrd+h ++SKRGMEQxCzAJBgNVBAYTAlNFMRAwDgYDVQQIEwdVcHBzYWxhMRAwDgYDVQQHEwdV ++cHBzYWxhMREwDwYDVQQKEwhNeVNRTCBBQoIJAJXpePU0UOTVMA0GCSqGSIb3DQEB ++BQUAA4GBAFQHLSELpa87WCMyXlZ/q1hjSJGqOJCJFvnMv6QOeCufxRtYpuYIjy6u ++lwMhm/HNwCaPHdcoJ6COgQkbHA/JpUE6LUQ/nPqH/8hMK0T3G8E+TwF/6SbMnxwG ++tQsn0RCQvpMMnOew0eonmU4GFAx66cFSxTNovGEN24E7V0hXv0Ka + -----END CERTIFICATE----- +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server-key-des.pem mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server-key-des.pem +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server-key-des.pem 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server-key-des.pem 1970-01-01 01:00:00.000000000 +0100 +@@ -1,18 +0,0 @@ +------BEGIN RSA PRIVATE KEY----- +-Proc-Type: 4,ENCRYPTED +-DEK-Info: DES-EDE3-CBC,D2BE7598C7E3BDA5 +- +-1W3qPgw5ut80OhaAGVZZe/tfFiBAlwpX1SohdApWj+QYP+dK/mdEBhgI3BXTFNLW +-pJqDTzGlKtft7hHN6QDFEdZMKxej5+2iLu14V62o+5yQgUoqswoXcmmqJCJ7AvyJ +-yMBmGAzxRFlQsT8lf6o5TS1/efBvjvWhh3NG2Zq2LpyhWRRqA3kNhzktzt2WjDZe +-ZkKmZJJnArr/Aw7jEBC4sH+nmgxoR18GzDddRG12hv1AWyHc3+VisTBpyNzeBy17 +-rxuQtqLzkAJmId723ddw83RVNSvBUUS3G0rx5O3HPobvZK89UqVxcXtIgc11WTVU +-N3DbcJq5it43Loo0W3gAngtESDm2E3rTadrmdUSDGv2wQ5dNFl6cQ1f397Sdd/WC +-A0grn1tKjJ6COp80Ymdyvn+stjv/+Rl1/KHSeG0lNeZxqjPPOJ7NHaKv7qjYsJ6W +-LT35/Xc3oCo5qk9FOlq/0tGjHxf6RcFr5U7k5ILKZs+RmvJ4Sv/VYShLfLTcfGbJ +-wBNfRKvcHZBQJQBb1+s/kRrjFFtvhrUwLz4+c9kskp+t4qRVYywUAnGGGsMs/GPm +-wYsLQZO6Bs5/taaVUyaJQW015J7FGGv+/7/A1dIhu73S/Xl/YcFbX/CMEVq2Lxxd +-hZdFIuaZ7LE+0MDQWsvYMYPDPLDH11diczb/jeKBdLPOzk/FUqVx3Fin1PpcaBxY +-b+7oZJhYdg/rAWDeQ/nji9qnEG8waK6x1hdkYPOrqqWQPfgM/LPsSrgWeuTSdx2B +-Ixi01UlBb5UP4K7UrjyddPobmcVjXaQLNe7zaq0+OS3UnIG85GtHrQ== +------END RSA PRIVATE KEY----- +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server-key.pem mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server-key.pem +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server-key.pem 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server-key.pem 2009-02-02 23:46:47.000000000 +0100 +@@ -1,9 +1,9 @@ + -----BEGIN RSA PRIVATE KEY----- +-MIIBOgIBAAJBANn92rP7fOCwA76XxqQ2rHGvuy3lhO3zjyvrEeWqZu2/YmvjzvqA +-7ZD/uUo5IEC28pm/LzO18uw6kGAdnpR+pBsCAwEAAQJBAMieYdpmRoUaODf9wqh6 +-ULXH/sG8i1vaXRcUHcJ50oRVfVK8/tGGvUuTDu6MeINTdahNDlYfjwOjKWVXys1w +-h6ECIQDs6s7DfczK2bKCLt0zqg24mZL3rOpGmDU+TatwN1yVgwIhAOuMzdVTX39p +-328+5WxJvBOFfxmSmqdDhIFpnRMvgguJAiByvKjT/km+970+1OllyvaIL0AA2OpA +-tBgdC0p6tyUMdwIgKuHAWzTJbu28UolVxQgLaFZmVCZ/ZzIAfnrWsLZ2a1kCIBq/ +-ywJ2cpyFlgazu8AH6KCQa0ok9s70ElaB6FEC85Al ++MIIBOQIBAAJBALaP5be0hoMTivm/Y8tkLblR0d6re0UfqrVmcxP5pgfVunz6kr03 ++4q2H2z62ahJk+O4X4xUGL6iCaL9XjcMEmCcCAwEAAQJASA5VwgNb0CKHiPm0ntOk ++hG+54SRX3DmafEy6gRjZIl/bZ/asSLhXUZ+CeohyrQh7BZgYWvykd8pRISL9eKsU ++GQIhAOXkUrOtP/EtjyqNluEqZdG+RZi/7p61JS3Ce13Myu+LAiEAy0uMlV34AJpM ++b40FPKqlHxw8DD/Dt1iKhNVAg8+LDVUCIFjv7fbJDbW2VG63/Cj8CAwOukoP5rbL ++iaicVrHBKrllAiB9+MiaXeopZXNrxDS0jQFYr8Q9yt1aJVFgUkxx4Q9HKQIgZPs0 ++KlF3NNNWw78INaAEkyf0IEssnLMsuoCWw0DIOak= + -----END RSA PRIVATE KEY----- +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server8k-cert.pem mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server8k-cert.pem +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server8k-cert.pem 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server8k-cert.pem 2009-02-02 23:46:47.000000000 +0100 +@@ -1,51 +1,138 @@ ++Certificate: ++ Data: ++ Version: 3 (0x2) ++ Serial Number: 4 (0x4) ++ Signature Algorithm: sha1WithRSAEncryption ++ Issuer: C=SE, ST=Uppsala, L=Uppsala, O=MySQL AB ++ Validity ++ Not Before: Jan 28 11:12:27 2009 GMT ++ Not After : Jan 28 11:12:27 2010 GMT ++ Subject: C=SE, ST=Uppsala, O=MySQL AB, CN=server ++ Subject Public Key Info: ++ Public Key Algorithm: rsaEncryption ++ RSA Public Key: (8192 bit) ++ Modulus (8192 bit): ++ 00:c0:8f:22:03:24:59:67:46:14:d6:8f:60:09:58: ++ 06:07:45:f1:78:71:55:f1:ea:b9:30:8a:cd:c3:3c: ++ b9:bf:65:6e:18:ed:a0:b8:c9:19:56:6f:c4:90:19: ++ c8:65:09:db:ff:bf:82:a1:08:ad:01:4f:5a:a3:d4: ++ 3d:78:7e:4b:4a:01:a4:7d:e8:7b:05:3e:7d:d8:b9: ++ 55:58:60:d6:1c:ce:e8:32:62:2c:19:60:f3:ed:05: ++ 99:6d:c9:77:07:2e:11:6d:0b:9a:c7:68:38:46:e8: ++ fa:31:80:df:e8:79:f0:f1:fd:a9:94:c3:fa:0d:f5: ++ 78:ac:49:7e:d5:17:fd:e1:ee:44:f3:c7:0e:30:32: ++ 5d:a9:19:25:e4:bb:21:1d:fe:3c:84:48:40:f5:58: ++ f4:bf:13:8c:85:68:bb:ec:f5:dd:c6:38:d1:b0:77: ++ 1f:a6:8e:4f:8d:e2:6f:49:74:f5:3f:90:65:8e:99: ++ 1e:59:9c:1c:b5:26:24:c4:b1:de:1e:fb:96:65:c4: ++ 31:14:1a:53:b8:5e:62:8a:c7:04:f7:b4:36:a4:af: ++ 07:c8:27:06:ed:dd:e6:f4:8c:62:f1:65:40:d0:9f: ++ 9f:a9:14:c8:8e:8b:74:d6:67:5a:d0:c9:4d:35:a1: ++ d5:7b:39:3a:42:9f:e4:d0:f4:c6:0f:2e:42:30:4b: ++ 56:b2:3d:6d:8e:2d:58:c5:69:99:35:49:95:95:99: ++ b6:87:29:2b:32:d1:50:08:cd:25:14:48:6d:10:99: ++ 85:61:3c:41:26:21:55:cc:1f:cf:ad:b0:2f:b9:89: ++ d8:4e:a0:18:ff:75:1d:b6:97:7c:c5:fa:8b:dc:93: ++ 17:86:0a:64:d4:09:35:d5:83:34:6d:5c:6d:c6:8c: ++ cd:b9:ec:c2:93:c6:c1:b7:cc:04:6f:22:e0:07:bf: ++ e0:d9:9b:2f:d5:a0:50:cc:f9:f0:95:83:8f:f4:30: ++ 83:72:94:d7:b5:4b:da:cc:9f:54:3b:8d:78:77:0b: ++ 24:6c:0f:c2:96:61:96:2f:b8:5f:b5:7a:ab:7a:5b: ++ 97:7a:a9:ad:40:8b:f2:d6:c6:8d:81:d9:94:61:8f: ++ 9d:03:c5:b9:10:03:68:83:bf:04:81:cc:ac:bd:34: ++ 89:e8:d4:8d:43:20:e2:b6:a4:11:3d:15:2a:82:0c: ++ d6:3a:6a:8c:62:d4:93:bc:c3:80:bf:1b:b4:2b:0a: ++ 7a:34:f0:cd:1e:82:3f:25:0f:d1:04:a8:0a:05:19: ++ b0:d6:16:83:39:af:0b:45:7d:cb:14:7e:4d:aa:aa: ++ c2:39:a8:46:38:ab:bd:ab:2a:bd:34:43:7f:da:25: ++ de:2b:fb:69:3b:fe:3b:87:fd:98:94:76:4a:bf:04: ++ a3:31:e3:3a:ff:6f:04:fa:fa:24:e4:2a:89:e9:0e: ++ bf:44:4c:72:85:82:3c:89:4a:03:63:01:41:92:53: ++ d0:82:60:6e:d8:ff:8c:a2:b4:1a:3b:20:6d:ae:74: ++ 92:30:4e:48:e3:51:a6:cb:73:97:06:13:03:32:23: ++ 9b:7d:a2:c7:3a:a9:af:97:8c:51:ed:fe:fa:b4:b4: ++ 1a:a3:87:fc:cf:8c:8e:e6:80:15:03:fd:fe:7d:bd: ++ b1:76:f1:5f:b3:09:2b:4c:4d:a7:7c:b5:72:b1:d6: ++ db:38:c0:67:a4:54:bc:87:09:a5:39:ba:1a:7e:3f: ++ 74:60:ad:3d:4b:be:94:53:f3:64:16:c7:33:35:ec: ++ 41:00:95:b6:de:99:62:a2:7a:28:9a:45:4d:fa:cd: ++ a6:77:f6:de:58:72:50:c8:7d:69:38:db:07:04:84: ++ d8:4d:39:f7:50:13:43:ae:2d:af:45:a4:2a:39:56: ++ 3c:b8:b7:d8:26:a4:36:c9:23:aa:aa:b8:49:0b:21: ++ ba:9e:7a:2b:7f:4d:29:9f:0e:00:1e:b4:5e:a6:fa: ++ 49:fe:8d:e5:74:57:d8:ba:d9:92:2c:d2:ac:84:1d: ++ f2:a6:a4:44:1c:bf:88:41:32:7e:d1:c3:2f:6e:bc: ++ 0f:5d:19:a6:8f:74:2b:67:ba:dd:a9:db:68:b5:ce: ++ 9d:25:48:df:54:08:d0:1d:4f:2e:5b:24:bc:05:0f: ++ fb:58:46:fa:02:ca:53:93:29:cf:10:27:c2:a0:18: ++ d0:f5:d4:b9:3c:5e:df:8e:6c:f5:7c:b9:b4:54:cc: ++ 39:16:5d:3c:da:96:b3:c3:6c:d4:70:5d:d3:30:a7: ++ a6:bd:6f:dd:41:bc:a8:de:42:60:59:9a:85:25:0d: ++ 2a:45:c3:05:b4:6e:7a:4a:4d:ca:8c:0a:e5:6c:34: ++ bc:20:9b:6d:4a:ca:ca:b6:a6:3a:a0:db:c3:0e:20: ++ 1a:12:1b:77:dd:cb:1d:7f:c3:0d:0d:e7:c1:fd:96: ++ d2:c7:68:80:99:a0:d9:8a:33:21:a3:8b:a2:5a:a7: ++ 7e:27:06:02:7f:ed:60:11:37:34:54:17:7f:4d:90: ++ 14:1e:69:37:0d:ba:f0:2b:f0:a3:2d:62:79:c8:76: ++ a8:ea:c8:e7:3b:1f:c6:4f:c2:0c:d7:ac:f0:77:53: ++ 5d:f0:50:b4:df:9b:03:ca:4d:41:e1:18:b2:25:30: ++ 86:1d:63:e5:67:b1:53:cd:6b:4e:83:1a:b9:5e:2d: ++ 05:15:6b:d4:8e:b1:97:fc:31:03:57:cb:bf:27:7f: ++ cd:5f:27:7e:66:e7:3c:17:09:b6:11:2a:4f:33:cd: ++ eb:1a:d3:6f:d5:15:8b:8b:ce:68:6b:7e:9a:95:e5: ++ 74:7f:17:57:d9 ++ Exponent: 65537 (0x10001) ++ X509v3 extensions: ++ X509v3 Basic Constraints: ++ CA:FALSE ++ X509v3 Subject Key Identifier: ++ 58:12:24:59:A7:3C:29:15:89:5A:C2:12:DB:E7:A5:42:10:21:B7:BA ++ X509v3 Authority Key Identifier: ++ keyid:F2:E2:EA:55:65:A4:9A:E2:AC:9D:97:F5:45:6C:F6:F7:8C:11:AD:DF ++ DirName:/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB ++ serial:95:E9:78:F5:34:50:E4:D5 ++ ++ Signature Algorithm: sha1WithRSAEncryption ++ cd:cb:5c:83:35:ea:cb:cb:c3:a8:c3:95:e2:e6:6f:4d:d8:e4: ++ ee:41:dd:3f:35:82:ac:2f:fd:63:89:4f:3a:19:d7:81:75:b3: ++ a3:fc:36:b2:12:d5:c6:56:bc:13:60:37:33:6e:a0:d8:ae:7c: ++ 88:f9:4b:ee:7b:1f:c8:f0:56:19:07:4d:bb:45:52:1c:78:81: ++ 07:7c:13:86:b8:86:70:85:e4:71:25:58:78:d1:be:de:22:82: ++ 6d:1a:4b:06:ac:f0:e8:50:87:c7:69:64:c2:61:43:cd:96:06: ++ a6:7e:09:a9:02:01:2a:a2:40:f3:cd:10:80:48:d0:34:55:40: ++ b9:ce + -----BEGIN CERTIFICATE----- +-MIIJHDCCBQQCAQEwDQYJKoZIhvcNAQEEBQAwTjELMAkGA1UEBhMCU0UxEDAOBgNV +-BAgTB1VwcHNhbGExETAPBgNVBAoTCE15U1FMIEFCMQ0wCwYDVQQLEwRUZXN0MQsw +-CQYDVQQDEwJDQTAeFw0wNzA3MTMwNzU2MjVaFw0xMDA0MDgwNzU2MjVaMFoxCzAJ +-BgNVBAYTAlNFMRAwDgYDVQQIEwdVcHBzYWxhMRkwFwYDVQQKFBBNeVNRTCAgIAog +-ICAgIEFCMQ0wCwYDVQQLEwRUZXN0MQ8wDQYDVQQDEwZzZXJ2ZXIwggQiMA0GCSqG +-SIb3DQEBAQUAA4IEDwAwggQKAoIEAQDUFlh/3mwov5YaICFXOdJXgHV/uDkTjXB6 +-9oxlipshQaYPX8LDT5vhI3gPciS1Z1sRE2dTcC4Mk2K4LDUIjp3WkeTfFAHZPV3E +-Y+3OH/ftH4N6SEIBTKE4EY6ah0nJtU98M0JhxOh5zHje6zQp1SkBnhEOQYexYRqj +-OtGloZ9RyF0iFAXcyu2Ap14u37l5Yla0cyPzvZqP4mFYlcXwaRfAacJmqMM1vuQv +-Fx1JITUTBugMF3VGZ1F0tw63EIUH/FW/WWncPqvG18na40qlv9ZkBw0FhZeKS8cK +-JIY5y4J30jn/eV8p1lTO7K+ASTuGZWmdRDgjUG0Y9OGuKsPPoaE6ml0HTnMBsBSQ +-fXUq9XkwGt8DTgPioAKHBHjLbILEy4FMYWrlTZlPTzNqyhayec/2T15oDladNSt7 +-JpDLpX70UECXFhdEGxsGxtXdKbIBvNm2yT4X2nxW9ItsECjSSgD+94TgGoa8QKDw +-rpmgq+Wqpm54CZ1vN1oqyMUw1sjNEX/iLByHAjSALby2Kffk5cl5mnsR6d/k4jsi +-c3Qsciwkd+rQt/8VMhS2ns3nkez/BK3FvQA2Ms8xJhFLfszVrBhnjcFRTNT2+/KM +-lr1oT5Q1XZKL7qVXTpabPL51JlVBL5CSHl1QRkffsqfqcgJkcHBq+kKjUiFs4lad +-hTrvNBCXYa5+NkA2QqIfdOpNwl62/gdE7/7zU1uh40vkVKyzL+APkLPywPEXBOpQ +-yIDNkgoXmS10+JMD44K7uZyUmxZL7W7Xbi30NuEFrVOzoUmVXhapPbpQnkQHxn8n +-tqKPYXdBcvXcCKyJ6i79H2Vk9fM6rBYiwNcE7QyWqfd2QMjzr76veF04sXkPR+tG +-5Y1lrF9Zp3vabFXQg2RJuGA3rV6MR2GFNXuChIYu410vhIhPNtmdKEVoIVZsFsug +-+dtn0PDCFrR8VEd/sshp0naNa9Ad1lY+marJkOJOVpPgCs2yJDPAUB/YdvSJ4avW +-6ZdvNTwhBL8fEJMS2DSqkaa6A3+i/SqITpU8ToJxsMGagBsLieXgvJALFysSRfR/ +-2dmEu9/J0PPc28inHXwjiLb99VKlkuEz8wX9UkuoqFl0pLa8jrlM8hzdPQ9QHb3k +-9c5knfgPCYkOIWwGXH+NwANHdQRK7CmGAFV24k9+P3q0g5ikabVHr+4ZQ3WPd+1H +-K0+Msbb/vv53vFJWa+pYeNeFcwNCyW2kJBTMiI6qmlL4IWCcX+QDzpRLalbAWWHj +-l5Zk39QEaCL024DYK948IDXCqDg6utEs7YnMdaIF0meYMKjehZFp0fVQ8e8Od+rp +-bbjdj/w60wMgBpSOeYxVrs3QKNZd/if4Az3LggoVHB09SjXKiWpvAgMBAAEwDQYJ +-KoZIhvcNAQEEBQADggQBABncOBW0wQwJdEB6W3d9CrhFp40q1OM54GPfX0/0aUfP +-aOQPxS1uCKcFhxAmR4OT9RiJx+0bhDctekkuMkj5yy3u0a/4PxHIhnVxXTyB0/Hj +-N1gLz6cQricunl6Q4Ldi54gR5/KUehKLBWnqsfxhgzWBHosvhlJC0xh/uio7JTqz +-ns60djyL7R4wGbSqiGdhT9L2HfpJo3dmmWLDxe02jaHkbL1Z6NQMxrRgs3+gctp/ +-Wd5UxNl4BHbNsSbzaK9V9gXUcj4TjZGGSqVki0+pEZ3dmksGZdoW9cSKtzKvgUQ6 +-vhhqO4dcopxkY2zYeVOpspgTm0XLZSbNPXv5rSFwa4cpWSfD7u8o8KhHvkkSMahw +-cMuH17W4voHHFDtWP8Oq9rA7uE/4/LKCl0JmJl2RWM+G6PMH8w4X4auHPssgRvb/ +-Ge1AvgqQJrvi7zWx3XYKKJ0ISBy7fi5Jo/wYgLagRYcG3mwdm1+gAdw+77C/ZGmG +-FbWFIPB1+Mc6azhhk9m/vqP7o/Wuncc99mp2zPMzdAEzuzp/IJ9UJNat0edA7jiC +-bQ7JSRJ1DSzdJZSWWHdardLNKipPfrEHVm7f5QvL5DQLnGpt+rCWL361KsGtvETC +-o+Ph7+kDJsJLokUYfs/BEZopzspNPy/NQ2ECwQp7T4Yq/PBE6Ce/dFaoZysMUOrG +-TcALtJW6It98dRmTJPiqjlrlHNTrfoV3Aiy+tK4rpyGuApSHc+1Y+t7YvWotRlQ4 +-GEboBqR8evjDPJ1xAaUZqwLkebf3mlpl4MzHM9uNWBkQdJilkQs/IrAaApG3Ayt0 +-nIymNHmDslBEdrRGmT4aNWAWYvVYzyKDy3H0fzYdWwuA9goJUL4tj3eMJa8pgEU/ +-rG3HfflVi+xuwm1UnLXPSIE8hixgV8ebnwcCnEjlUBvwpl7f5Ub40jKcdycdGvVu +-gcTUzuRl1+Ikfk/MXKPbdi4A5Pjtz6AG4Ez9q5j7X77JqskTI5Z/f1RPiKwFBJHg +-cN4+BPnEuSWGcjiNDOfQxhk5exlWRf/gpEhnQpGHe3a7tZgfxHUb/pWU9BYpf8OH +-vtV3WSDXlUqsEEH6/bmvj8lmFWJLmeZv+qLy1wHxcXR9/GJ6TwCF8niQIl3MrBAL +-sKPLft1drmpqdIQpZQIJxtN/AQuD9mxEdW7XA6rkvFySKcswJpS1QjkSWpafCBWE +-wu+SPxZL8oFrnNMTU3JloUjcRp70FkNXLLm/Dy+MjW2qFBtIoBgNptVGp94L1uZS +-amd2XJMcOQ+X9fcH3wAdM3IHGn3NiLf6eTW92JNNA0IN6aNtyVaJKmFJ1JfXOl9r +-ujr4SorRSesaerjIcuzW1u1YE5RlgeI4kizV2/D5kYc= ++MIIGJTCCBY6gAwIBAgIBBDANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJTRTEQ ++MA4GA1UECBMHVXBwc2FsYTEQMA4GA1UEBxMHVXBwc2FsYTERMA8GA1UEChMITXlT ++UUwgQUIwHhcNMDkwMTI4MTExMjI3WhcNMTAwMTI4MTExMjI3WjBDMQswCQYDVQQG ++EwJTRTEQMA4GA1UECBMHVXBwc2FsYTERMA8GA1UEChMITXlTUUwgQUIxDzANBgNV ++BAMTBnNlcnZlcjCCBCIwDQYJKoZIhvcNAQEBBQADggQPADCCBAoCggQBAMCPIgMk ++WWdGFNaPYAlYBgdF8XhxVfHquTCKzcM8ub9lbhjtoLjJGVZvxJAZyGUJ2/+/gqEI ++rQFPWqPUPXh+S0oBpH3oewU+fdi5VVhg1hzO6DJiLBlg8+0FmW3JdwcuEW0Lmsdo ++OEbo+jGA3+h58PH9qZTD+g31eKxJftUX/eHuRPPHDjAyXakZJeS7IR3+PIRIQPVY ++9L8TjIVou+z13cY40bB3H6aOT43ib0l09T+QZY6ZHlmcHLUmJMSx3h77lmXEMRQa ++U7heYorHBPe0NqSvB8gnBu3d5vSMYvFlQNCfn6kUyI6LdNZnWtDJTTWh1Xs5OkKf ++5ND0xg8uQjBLVrI9bY4tWMVpmTVJlZWZtocpKzLRUAjNJRRIbRCZhWE8QSYhVcwf ++z62wL7mJ2E6gGP91HbaXfMX6i9yTF4YKZNQJNdWDNG1cbcaMzbnswpPGwbfMBG8i ++4Ae/4NmbL9WgUMz58JWDj/Qwg3KU17VL2syfVDuNeHcLJGwPwpZhli+4X7V6q3pb ++l3qprUCL8tbGjYHZlGGPnQPFuRADaIO/BIHMrL00iejUjUMg4rakET0VKoIM1jpq ++jGLUk7zDgL8btCsKejTwzR6CPyUP0QSoCgUZsNYWgzmvC0V9yxR+TaqqwjmoRjir ++vasqvTRDf9ol3iv7aTv+O4f9mJR2Sr8EozHjOv9vBPr6JOQqiekOv0RMcoWCPIlK ++A2MBQZJT0IJgbtj/jKK0Gjsgba50kjBOSONRpstzlwYTAzIjm32ixzqpr5eMUe3+ +++rS0GqOH/M+MjuaAFQP9/n29sXbxX7MJK0xNp3y1crHW2zjAZ6RUvIcJpTm6Gn4/ ++dGCtPUu+lFPzZBbHMzXsQQCVtt6ZYqJ6KJpFTfrNpnf23lhyUMh9aTjbBwSE2E05 ++91ATQ64tr0WkKjlWPLi32CakNskjqqq4SQshup56K39NKZ8OAB60Xqb6Sf6N5XRX ++2LrZkizSrIQd8qakRBy/iEEyftHDL268D10Zpo90K2e63anbaLXOnSVI31QI0B1P ++LlskvAUP+1hG+gLKU5MpzxAnwqAY0PXUuTxe345s9Xy5tFTMORZdPNqWs8Ns1HBd ++0zCnpr1v3UG8qN5CYFmahSUNKkXDBbRuekpNyowK5Ww0vCCbbUrKyramOqDbww4g ++GhIbd93LHX/DDQ3nwf2W0sdogJmg2YozIaOLolqnficGAn/tYBE3NFQXf02QFB5p ++Nw268Cvwoy1iech2qOrI5zsfxk/CDNes8HdTXfBQtN+bA8pNQeEYsiUwhh1j5Wex ++U81rToMauV4tBRVr1I6xl/wxA1fLvyd/zV8nfmbnPBcJthEqTzPN6xrTb9UVi4vO ++aGt+mpXldH8XV9kCAwEAAaOBozCBoDAJBgNVHRMEAjAAMB0GA1UdDgQWBBRYEiRZ ++pzwpFYlawhLb56VCECG3ujB0BgNVHSMEbTBrgBTy4upVZaSa4qydl/VFbPb3jBGt ++36FIpEYwRDELMAkGA1UEBhMCU0UxEDAOBgNVBAgTB1VwcHNhbGExEDAOBgNVBAcT ++B1VwcHNhbGExETAPBgNVBAoTCE15U1FMIEFCggkAlel49TRQ5NUwDQYJKoZIhvcN ++AQEFBQADgYEAzctcgzXqy8vDqMOV4uZvTdjk7kHdPzWCrC/9Y4lPOhnXgXWzo/w2 ++shLVxla8E2A3M26g2K58iPlL7nsfyPBWGQdNu0VSHHiBB3wThriGcIXkcSVYeNG+ ++3iKCbRpLBqzw6FCHx2lkwmFDzZYGpn4JqQIBKqJA880QgEjQNFVAuc4= + -----END CERTIFICATE----- +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server8k-key.pem mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server8k-key.pem +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/std_data/server8k-key.pem 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/std_data/server8k-key.pem 2009-02-02 23:46:47.000000000 +0100 +@@ -1,99 +1,99 @@ + -----BEGIN RSA PRIVATE KEY----- +-MIISKQIBAAKCBAEA1BZYf95sKL+WGiAhVznSV4B1f7g5E41wevaMZYqbIUGmD1/C +-w0+b4SN4D3IktWdbERNnU3AuDJNiuCw1CI6d1pHk3xQB2T1dxGPtzh/37R+DekhC +-AUyhOBGOmodJybVPfDNCYcToecx43us0KdUpAZ4RDkGHsWEaozrRpaGfUchdIhQF +-3MrtgKdeLt+5eWJWtHMj872aj+JhWJXF8GkXwGnCZqjDNb7kLxcdSSE1EwboDBd1 +-RmdRdLcOtxCFB/xVv1lp3D6rxtfJ2uNKpb/WZAcNBYWXikvHCiSGOcuCd9I5/3lf +-KdZUzuyvgEk7hmVpnUQ4I1BtGPThrirDz6GhOppdB05zAbAUkH11KvV5MBrfA04D +-4qAChwR4y2yCxMuBTGFq5U2ZT08zasoWsnnP9k9eaA5WnTUreyaQy6V+9FBAlxYX +-RBsbBsbV3SmyAbzZtsk+F9p8VvSLbBAo0koA/veE4BqGvECg8K6ZoKvlqqZueAmd +-bzdaKsjFMNbIzRF/4iwchwI0gC28tin35OXJeZp7Eenf5OI7InN0LHIsJHfq0Lf/ +-FTIUtp7N55Hs/wStxb0ANjLPMSYRS37M1awYZ43BUUzU9vvyjJa9aE+UNV2Si+6l +-V06Wmzy+dSZVQS+Qkh5dUEZH37Kn6nICZHBwavpCo1IhbOJWnYU67zQQl2GufjZA +-NkKiH3TqTcJetv4HRO/+81NboeNL5FSssy/gD5Cz8sDxFwTqUMiAzZIKF5ktdPiT +-A+OCu7mclJsWS+1u124t9DbhBa1Ts6FJlV4WqT26UJ5EB8Z/J7aij2F3QXL13Ais +-ieou/R9lZPXzOqwWIsDXBO0Mlqn3dkDI86++r3hdOLF5D0frRuWNZaxfWad72mxV +-0INkSbhgN61ejEdhhTV7goSGLuNdL4SITzbZnShFaCFWbBbLoPnbZ9Dwwha0fFRH +-f7LIadJ2jWvQHdZWPpmqyZDiTlaT4ArNsiQzwFAf2Hb0ieGr1umXbzU8IQS/HxCT +-Etg0qpGmugN/ov0qiE6VPE6CcbDBmoAbC4nl4LyQCxcrEkX0f9nZhLvfydDz3NvI +-px18I4i2/fVSpZLhM/MF/VJLqKhZdKS2vI65TPIc3T0PUB295PXOZJ34DwmJDiFs +-Blx/jcADR3UESuwphgBVduJPfj96tIOYpGm1R6/uGUN1j3ftRytPjLG2/77+d7xS +-VmvqWHjXhXMDQsltpCQUzIiOqppS+CFgnF/kA86US2pWwFlh45eWZN/UBGgi9NuA +-2CvePCA1wqg4OrrRLO2JzHWiBdJnmDCo3oWRadH1UPHvDnfq6W243Y/8OtMDIAaU +-jnmMVa7N0CjWXf4n+AM9y4IKFRwdPUo1yolqbwIDAQABAoIEAQDI3u0tFoWMRoCs +-99d8HLiaxYED2YC9gw2QeKjal198LQhRsVnu0ByMLKLOxkX8RgrbbmxDe5Exufob +-A0urciAOFJoXqoRhs5x2oEqgGmkf/ePx0jQptOFREFfnBdGeKIpC0O3DWdLxYPbt +-8wixwkEXVhVDUk9pcdXf2ZqsbBpQRBvpZdtzlgNCAcLTVHP/gmMqf48CkIauVjPq +-ydfybibfx4sm3hodclH+Q78p/zicb8MhiKo7ZymgCKz4N743pQe1tsLrpbPeHY0C +-MpoFyF8O2Bq+KxwvELxQX+19GcHVKJhj3hmCr4wde9BxCWtGTBCusekVkVvy8iQ5 +-aCmTIrtonMEVZXjJlXK0sw5hBKOmKx0jrSVC5FfgdxzNVlW4fCJXLEEpMsjMc+/3 +-6bV7jqGn4N5CYaopNS2ccxdaucE3NjcmofahO6bqUTJHSPFecfYmCA42W2m+ldjj +-HZ78JLkyw03nT1hjPjbwHf5FTem1KfKg4EJrDprowMT7D8KZb0SW+z59pFoDOM5u +-Heu6sOSUtvpvKfozdw2ZAI58dhpW4/jTfCEtewRhPqE3/V7g3haTnQFxU8gm/a4N +-uefZTCjFE16QWNuvnUrJWw/DlvOBY8GjpQCWY0mDeBHPNOI0Xg9oRTgOCrKSLUya +-YSbg6BmhSKwKsYQU834jrQb3fXFlXZVIxlcNePOWMhHFFNAHucHF822Nr7u/3FOT +-twcbBIOXCGfDT6ed8d4dNum1L7k9Blju16CWkfuciL8PGXY4mGAmF4nZMXGZgK8B +-Cz9cxhtvFLe8gz5615DtBAsuVm7Q4AAHiULAMg6t6auyxCb8pXbAL0Ec5X4zS3+f +-I2riODYiyHCh/qTtjawOzUZZEtjZRMSDi+jk8wjjDdkFU8McOaYoPyqT3TDy2v6m +-NiPJs8GWQ2NCNo9CNoGbEIIFFP5iSz18XLFAOF+2dN/KHHl9nKyi7kOhYbbzoNku +-2wQV40yVsrS4E/hd/7+2IB2Muduxiu7NxCUSUXsw6p0hZTYMpIoduEfRSk1al0lS +-862GD8JgJ4RhJ0uIOTDJS52MQmO8zFIL86emdjjV1CzVvadYSQLTX7ZgR0i8g46A +-y0muCFAC8EJpnEtHzqtQ/z22zB8TCJShFuUK9KF6K8nOlbc6ShcUXU2J6r1sc8aT +-Dx0yzRXfCL15fpCJBP49EYaKhArTNmFRa2GaLiJP0OYkTrrwVOGuS6x2+kRVoP/8 +-BcNMZ5x8mXP1LgotHCztgMKX30Hn5CLxbH8QfcWKemGva1jBmhCWxS17Gh3Ld9T3 +-/WKkBa6JDq83rlO84x/iF3mB3tYkZPfcYtYURn5wwm/BmVV/9G1VwAatJdxmfCSy +-5JwC9WDBAoICAQD7xStPk3lq+qYHAtLZidujmzSNv7XG+E8UC9yvMRFuBwSM5ZE4 +-YGD2LDev2nghB+7OSR8KJIkxeaNjP91Zf3s8wjCuxLg/cLGI6mf6uWy9+zypFg3i +-J+ylDKa6NBuqYyY75W7Pj63xvGQlw5kX5+mB3ulQbActT4cUiVdEkyDytzubqLzY +-s15QGFrL9gqLow+C+7LKQKdeXq8OavFV1PWkMDAJUki6cIir9m+f5Mqr2cQCLKgx +-38aX8c9UWJv6pI5zQQuBjpaBOwz07WnyTXiFpc71x/8i85uLGDM0e3VO5ZPGeRBj +-jZ0ucHatOHJ3i/nPRG16rsPR+q97QiDHoLF0quHEG+ND+rwTBzNGIwzYRE16p1o3 +-UdzFk1RzlDCfOX7QgszCwK6mf8TbCK9f/FxJ5e6TCkt3iHXSrlLS4op6k9nEpKFH +-KHf4nPtCy9GriP+A8+dA6K1s+DgejoIojBMBTsnl4TEf+m8BaenTXGuU7KYyc8dR +-JqmpmDggDRT/ImHRhXirY7lIIYXnI7tRjN5gmnKpEiHScT1r848zpQ4gWH1Dx/ks +-mKT6NZ8nF45saQCYbKEYc0RH9Kw0O7vr1kVtNPc2dEZtVgt4bC5fnl7xX1/YTk3m +-+h1qfzbku/+MX5rRjHLR2l8a71UltlnnnpP5NKBBgtxll6aCIkk6CdH8YQKCAgEA +-16aBaVa0cOZmiOQwPQkpuXIbV7msz1ttWEAHElCy6waniOCON89PYFCb7F0NjV3Q +-i+pGaRgG1iZGbjjHwyqTrHhMloFm+IsSWZqOZzrHgSJgA4bgTJFgp+5b31sQXGfJ +-14QQSqMJLC61/M+CnrNtiuI3IVHx6BFRxI42uE7PfTyUMaFhL9F0/SLl0Mw0oMPj +-S5kmarduuKpRn1tN9WO+ywEvYwopvH3e9PBssZzPpttlLiE/Wulb0iEtlVXYB9DS +-Vzc94N2dzFMIvWUDF9BQ+IBMRzXRm15Psy6LfzoK+9S6w38Dx3BVV8ykSMKeW1UR +-ZwTajjdnIBLdE3onD5XMmrSOPw/WtV5zXEYY4DObhIPoN2iD8GJP0IubPb6fonH5 +-VHmuVZoXrroFEe7rdt2wgmBdPPl6fqvBKVhjJOpYQctrFLgWh63bXZKaBWqbQM9W +-fECq8We1VN3fzqwfwJQit3z5R/DjQNk8eQx7SnnkOzAY6ZgpysHCwaoPOnPVuiYF +-ZU0+X3iwfsdeefWmGEDIzoZk6nYaljs61lOhhEoWHngZHDkMOp5kg0n9f8BUP02+ +-WJ4QhwzZ73hr4FPBuPHHXECw9TCAgCBHBFrnrXg5QalDhRXz4F+3tCY7UUpD/ikZ +-L6Daxm5zGJ5u3rXs6WwKy2EHVVS9zfqs4Q259pQdWM8CggIAcIKpGzOVM+h033c0 +-kIBZxeAq+Rlt+0+lzxiJ80RjPJ8oOmqwndf8HKaf8BcaTfCEmGz20QqIwLJSAJ1e +-posgoINLTB6fE8Kho8TU2KeaX7/xWMKBS8p5pzxjGZ0Fq/wI7wVVoq3blsaQnout +-U5CQujfKXeUYw/fhLp09gWiadbzKh4I9ej2V7QclNDZsegBRg0BForqH0NVRN4k0 +-9h1n9IqQPOonlCGMAgTr1zFgHLIBNNOOClOtJOOruk6qzbRR8FFl+eyld3TTEnUy +-PlS+gkMZnJ5WduEUZnFXGKH/R1Wy1yPs3gA/+KvLbRdnl+LWrPgwUH3fBmwXlWZ0 +-zaETDEb9Ay1PP2bCO2KhWDt7lv3W/fPhjg0oMqbnO4tCuzTvZfC93l5K7h708skL +-zkIxX9i/57fXB8DUnmTGoHUaWzLNQ2IqrGj6TACjDDOXLCfZvl/AvTH9pk+6jHU0 +-1zfZmmECOpeK43Z/ussA8jI/5Vpn3u38aVh0w1RB6JjQBD/yJLaXuUekWgaZFzTR +-ldz014jNqp5uvONcBmzeVr7w9CV3PR4VTQed2i6yQ770J6A44uTQjOOd5OYDOohj +-Lz4e4nGj9BK8Eko8cAEwLAzS8tyjMT+08n5dPOVCu68DwVBMGE7CVONYUuoXS/YU +-cTxddiU9ZGk9Yq0FfOwjeys+SqECggIAdn3M2b6Egwx2Bn2ra74fKQBjub4SEBWi +-bT0xJYUl6jHL2E/alRvZ94gTRLqUebq0nkxpx9El4IFDbcjRKpG4dqnbG0+a7rIr +-sQRVfq8zc+cZbparpCa1P1CfNojo4n080KiF8xzGK3q3EGRM1zqr1AYcWLiX/PWX +-QjMKKhdTtvKUUvjjV8z1RSnpsOKjgDpiJ+XM0BJeSiV7l94pZc4axZyvFvI8oI9g +-9KEueCE7j+k5HTGziBZ1F26Xh1iVzSWWjcmSvH3I+L4fLUHVgz45X3HPd8lAlOgr +-Tr8icxPHeTwYKtcdknZMzmNpWXlmXbTOTRbDqCUVCvCSfOM/lzauJ8tR5aCkTx/I +-r0js3jQ9HYEFFXzeEjVSubob4L9fI3kQkLQTcIGsxZr8si/fPX7uP5UHZjuGbRee +-mUMxptUFDZHiEo5cAs0qna2x54v+JoxGbxtxUhez8R/Am+TDxaMfuEZ5Cmh31egH +-bFPJYtC68TKqXZ/4RqpUgukYWPvQ0emWSWU6AmdkQyT06nppeyYNsDz0MkgWr7l3 +-yNBHDVNP+Anxcip+Z68kd2cuXQWmxOnIzxR67FnJXeWDEM20whRHgI8jLHYsBTq3 +-CtOQPSaz/zosGXJIgF7Xp6riKPZvibW3Ww49Z47EuyBCtyirNk7hV4LG7sITUJyO +-ZVKPfcdAoM0CggIBANz3EBZGyt3af2UjFFKbazV01KcHF8OxqdQzsLqHCXWb98V6 +-PggQnrF76U7DvqOWho9djDBPrbQU55HG5nXq+eZKPwhsOdwQ8bxOhaVxQcATZOI7 +-FtJYnjM1/+zMzzS0iPR5DA2pbB3AKH2Z+wODmF23CK2XTwoJyPKxvlyGKrIqq3gN +-kOmocNu2Qm5bJf+D/hYPm5Ust2wzD52NnvJU536bZ0ZMo1/kaK2idqSAzqo4TkR1 +-j9U0fdW2rIBDo/qFmBBdJhYVjYLj4qR8CEEoIjshD4Nztf1xRM5C8irE/gJcT5+r +-4bPJJ5TjAtHxPiQqZruSprSEUbMsPqBap64ow0SmbNNWSgyaz2ha1rG0p52NBzH4 +-XM52LBqS9QHPHvB0ooYfBTfPpDM3CePuuNyzjPAw86ncUo38FKXuc2oViJJ6C5I7 +-v2sKhLK5gu3uPBB2ludDEXSpWBqiraynolOT/o52r+taYp9YY2WU3GrhOiV/A1FV +-Nl118xiF6FOFpEeTbhHvy27A8kZEKXgeSs+f4aC0XG9kLVD1CiCbQiqHTDcDS4nV +-O1N1eQxhP81X+YKE4Lgufh07REqYVwtCj2lQcMp73WDyfBLKTEFlmHusoqmT5JCH +-X0BWNjk5Dn1g5h63/lQb+EjNRILBhDFYhrDRDQtw5p0/7IY3AcNKDUHv+XGn ++MIISKAIBAAKCBAEAwI8iAyRZZ0YU1o9gCVgGB0XxeHFV8eq5MIrNwzy5v2VuGO2g ++uMkZVm/EkBnIZQnb/7+CoQitAU9ao9Q9eH5LSgGkfeh7BT592LlVWGDWHM7oMmIs ++GWDz7QWZbcl3By4RbQuax2g4Ruj6MYDf6Hnw8f2plMP6DfV4rEl+1Rf94e5E88cO ++MDJdqRkl5LshHf48hEhA9Vj0vxOMhWi77PXdxjjRsHcfpo5PjeJvSXT1P5Bljpke ++WZwctSYkxLHeHvuWZcQxFBpTuF5iiscE97Q2pK8HyCcG7d3m9Ixi8WVA0J+fqRTI ++jot01mda0MlNNaHVezk6Qp/k0PTGDy5CMEtWsj1tji1YxWmZNUmVlZm2hykrMtFQ ++CM0lFEhtEJmFYTxBJiFVzB/PrbAvuYnYTqAY/3Udtpd8xfqL3JMXhgpk1Ak11YM0 ++bVxtxozNuezCk8bBt8wEbyLgB7/g2Zsv1aBQzPnwlYOP9DCDcpTXtUvazJ9UO414 ++dwskbA/ClmGWL7hftXqreluXeqmtQIvy1saNgdmUYY+dA8W5EANog78EgcysvTSJ ++6NSNQyDitqQRPRUqggzWOmqMYtSTvMOAvxu0Kwp6NPDNHoI/JQ/RBKgKBRmw1haD ++Oa8LRX3LFH5NqqrCOahGOKu9qyq9NEN/2iXeK/tpO/47h/2YlHZKvwSjMeM6/28E +++vok5CqJ6Q6/RExyhYI8iUoDYwFBklPQgmBu2P+MorQaOyBtrnSSME5I41Gmy3OX ++BhMDMiObfaLHOqmvl4xR7f76tLQao4f8z4yO5oAVA/3+fb2xdvFfswkrTE2nfLVy ++sdbbOMBnpFS8hwmlOboafj90YK09S76UU/NkFsczNexBAJW23plionoomkVN+s2m ++d/beWHJQyH1pONsHBITYTTn3UBNDri2vRaQqOVY8uLfYJqQ2ySOqqrhJCyG6nnor ++f00pnw4AHrRepvpJ/o3ldFfYutmSLNKshB3ypqREHL+IQTJ+0cMvbrwPXRmmj3Qr ++Z7rdqdtotc6dJUjfVAjQHU8uWyS8BQ/7WEb6AspTkynPECfCoBjQ9dS5PF7fjmz1 ++fLm0VMw5Fl082pazw2zUcF3TMKemvW/dQbyo3kJgWZqFJQ0qRcMFtG56Sk3KjArl ++bDS8IJttSsrKtqY6oNvDDiAaEht33csdf8MNDefB/ZbSx2iAmaDZijMho4uiWqd+ ++JwYCf+1gETc0VBd/TZAUHmk3DbrwK/CjLWJ5yHao6sjnOx/GT8IM16zwd1Nd8FC0 ++35sDyk1B4RiyJTCGHWPlZ7FTzWtOgxq5Xi0FFWvUjrGX/DEDV8u/J3/NXyd+Zuc8 ++Fwm2ESpPM83rGtNv1RWLi85oa36aleV0fxdX2QIDAQABAoIEAGv5ltvmLQ/A93xc ++x0BWEINRkBa2jrfpo9B5dOnuikWtza/Cx+X2NfQHFlSrcHhfr/JX5BsCb2iVo8DM ++CXAgeX1VMHS9wQXuxciaHCZDnqxmxUNDU3EjsYQOKLusRcdL6M+Zuz/ny+7PQ0Qw ++/N0yS46Wa9oUjon3RKRvTeSV4HIpFpcP3n/eLjDc/ielWuujnTGcBnjNWegvQROp ++5/7221YElGh8U84kbK2l9DtfjwoGoTv11lPvOxXE/scg6em7r9j+y3p3TMzMeDtT ++YBC6CA4Oa7GrWLJXROOKOQ0ddtvFNlUsZ02vG2QCbqU2y8mwJrJDI80qNbeKGel3 ++SfwkssedtGoOOYHxNczwpyVNHVHrHuMPBe75gbo+5pFxVJ5ymCGWfbLJf73oVsqW ++ZimoknvkozW4+mlVlcmo3X73IxTW2U4RlXthYdj9KXsBLRaKVCQJDc934eHWkXHU ++GF2U2NonqOVd8YG/FmZQ2ig6EcW97hC6wnsWT2Uc7UNAE2RM4bY0xCUHaQiKTrEs ++CI6wpbbTV+XhDu2HmL9G+fsuSIu0RoSOCmr5jQDAVwCNPXFgBgcIxbPZ/UCJ7RHj ++GrWPBldAN8ip4osiA+B3XwBabcvwXP2fgBP/eLWN1St3q3tw5xpHpqCuhNuPSqsc ++0ntz0oIdJyRR6fXWmRFex4kXQ597z5ozm0uyg8arV3HJFxDC3DI6kKfs86/oqMSW ++l+9g+d4x6VrUOCTDk0bjN3T8HQ9ASfy9JVacqk6yuXX7a0WeeT+x9JsvFAjg2KmG ++CJUtm5w5siItMDSPpcRE4hlfgh+M7ZKS3PFgH3vvwfPMbC/IC93QoSaFzRJMyobX ++ei6PNwqJvL+HADlMfLmehE2w9ycp4Fe1Gw/NW0Ed1S6Ajo45hgXQJSIrzla6eglg ++JPsPpQ8b+weZNQ8zvc0KvfRJmZKKEb9dHvFdi68I1kV8aapQsjrMOjwHC2pnCFh/ ++axkVc7a59fKUs7L6nAJhCs2sSixTorZz5PvJ6mXhWu72TCzu+kThNnEORrlWPHQl ++RFEAFpDDaGSzOMlhb92CWUMPyZU2qtzMzv4QGbP5YqTy121hXuT5OBKCF3eNLihV ++aje16k0RMFqqW3Olbm7Mp2P1C6DuwzsUJBnNwB5JzhC79Po88zNAl2d1h+qysKU1 ++jxF316nhpWJ2dGJ/sbJ+XpUMd/tVrNFQMA254GFfXycsfBoQOSY5d6GfRwKUDOou ++xImbIzGUAaIYdsGKDuKtqs5S21JMJjJ/J5CwjLu9tbpP/jsp22KHCpraHAQCupSp +++SFwWI7tRUXzREuxJixfUOnJFQYOATnMFvvtk1d6v4xoPYCVEhHq8gHqJkTyTi3Y ++BPVwT1UCggIBAOEy5gThTrEqSVFUcFJm9bJxtWZt/YhOIJWNNxeaxExHzy5hPpsw ++fZXtN4MUCeMSWI4isgIujmltwgOHMjQqsJPISn/1gVrqLmrZ2PnFzko/WA8rMUfd ++EUnOOpj2bKpChlRGHi76ZV4XGgoTXyO6mrVUcUgf3reSImdcdQ5IHa7J+lWhCQGb ++neZIyDOk41LX1TxjcYkY7vuUgmbBYComXPm2UaY3HN4E/3ElXntj6PrlozL33A56 ++z4UPfv2Vv9kl0ydkTJe/WcUN2htqLFCYygF2XLlwbv2SYDCT31PkJUORbScUM46A ++DOhlxvLBFcpF+l0RtCtvnrKyFy9yZJKrcLh9x6xVChZ/aQqSptSHjll5IEcVm54Y ++Z1TjWizCI4txnaBFV0UCLt1CZrllXnyIksZLS4/dVqUIKmkxPBQUpiD5dmgDcmPB ++/LdWzS6k4MH3J3Y3tu3MNPHDwgUtnifSZrsWSYPK0F8J0dMU/mLaS9eOplAH7Eo1 ++t7OrrImvitM6tUdErRYilIaoS/6YPmsPST5gY1N4n8Lf4sAE/tY8fwaWRpTVSrIw ++CoFwLtHESUOhqfuAOdr1EkDfo/RQTUVdnmWZ+D0j3du8MmsMje4x3f2CjBDXqArl ++gNnBQELDmrdif8KELNjlEpTIz0T7wEfquhVQ2dzhFpL7RLAgggD+oEBLAoICAQDa ++5WOWrAtaI1cC5C7LFxM2qXTHGRttfAtVxuigJapLqNASJuu59GGRxsCVwhthbNFh ++aCMSj+fZK7QNFkaoPwuZCEtzy0ErkVZzxYp3cP6b99mzGoCcuqiHiW5qhEkbxwdC ++f3YEsSGqE6j8TPW8feiziqo8q+QPSudI9ngkH1gjgbIrTu9iaxKJcF2CwBxe5tfB ++uFBNPIgJAaLPejRKQu17MAV2jDnBDIsZUZnm53IxQ+giIYUBay3cfC1KMJu/AnZ/ ++CxETjgqqnzqdFW0b0o49Q6YQa6QXAiSjs+lL/BhjbdA5quVdFmA3CoASFQbihYfM ++4vilUg7Y4wXfzS7DyBZdfppIn+HI8PPSMv/lfdsQXecl5TU1fBDPRWYPpTZqm1II ++HDCkmGRKet/j4/oobabNRrJ6PJcxNjqeMVv/a72pypDRPIXzNxLb1BkfWDGfgu2R ++YAdRNBSJSpdoHDZ+1VO2A+/8gz9Zuiv1WxoX7+u3pCAd+0vCfHiaXiFVc7fI8F+m ++rtDmN5p3DD9l1+/v7yd+7eUezwxYecElw5E5MyAJRTYGrim8g7XvF/u9rXvH09VP ++TeIE8oJ7XzrxCmtGIxlJs6FmgUbUblOyfPZDUqPnzlo8Ru1H2iKRo2FPiMfij8mh ++H3wgFTnZpGDQjw/xop51bxVueXrmOeguS0wmk/8Z6wKCAgEA0y+bPApadJRWS1nn ++N69sTBqMZfFR6Eh0ECts9criuTJCXZk+T+SqcTYTb+4T04k52Jk63Aby8HXIkuxv ++LTK3gu86xkLiOvMP8o43Bwz0BvbeSuNThLQQ6Wjn1NiLUSOvu0pCNgYFl7YMalR+ ++TRBK0y/MSDny762wa8Pt1iXVCDxLcY/h1UstSW8JqDzCHcdgJhCPwWTLgMxleZ1w ++5DYzzM2oRjq67I49Sssjjo1ESD2fzUVZbY7IG11L1t1fG3F4UiGiHlCJC92Qo1Lv ++Geoezj5EeHay70Mcx5F0xsRWGcZAWXx9WO5GrI39g1uFZro3Lp5SmsVDSwrt6UXa ++gR0bSThTTw40tqJnTE34+6ff25JWrbLay+jQxm+q+fxZvwQeMNW2IHYKot4JXWVt ++tVWSZzjnNJP6FCvTMfDFCYPPw26OFr7cwCaEKx7QriRazitMK3XWK6zsHalZwudj ++wK50PpCJAnno7KdVySCP6v4ST6Rr3POBKJq1ml2tITWo96u/ooUJ2I83QAyFr8zw ++BBBCvKdBnl6pW+P/TdmhbiEvcmrs59gaA34/6+DbV0Y++piZwswd9XML2iCgLZY8 ++0IcZ6uf4PsXq4Yzcrz0HwM+tAXcyiPzkjstpCUxMShALgFxzuWOgdwpjYXnrviJk ++0EyUkzbOCHBhbhcK9CyYHfyrJX8CggIAdWwgJC9eV5glkPN+9osGT4hPkI4zXGPy ++YK03FNGfrL59/37JbRNfU6fen3dk4LpTB4Gpbserg6AiEfMlLBPF0O3WK+OYrhpk ++2e3Z/YCr1Fb8fUt2Op0W0r4ycQlNfo0ho9ZkJNgwSuAJAm72U4rnTYjREYLT8DAq ++KcWtZRM7YLCuNvU9DPqLExcn0n/juDT1AIIy8XvLLamnAM15R2znn/F+vL00Lg7g ++f1B60pbNdwgKemSoyL4J+ADU+rtgkPJtRnFVU7walLSd6K4ZvZcRnmOvrZdQitcn ++eHmGaLBvFMdPr9+w8mKScnQ7h3eoHdOrqYkIAQcn18jQ2eFjeLrY5IaJlPPPVs+K ++u/OHuj/tR7ZXzMhL5skK62U6/qGNs1pmgts8bM8i3aFUgRdGlnFbzTpje5cNM+T3 ++RO0NgNL3ByIW1Wc2I+YjQ7FfWKUi2YKOljGBO1pIue09kyevRBKDuVwbXMW7MhLg ++idm5AaY+OGDeqbaoSUgkGgrsrr5IlI39gZi9jwG85qe3Spavq3ILKdfL1N8UrFGD ++/xIN0TVPtilede7vjKTK79tZu8JYaDWGc+g/mo/M1wmawLrqGNGzOwoVRruKl2In ++m9PU9wBZ1HuphDQ4DRdC/AU8qkGhmDOx4bDWEQ/R3KKFHNvhnamyfyR7xqt79gyS ++NGNIElnJuskCggIARFaK6yAVmaL74Qu3iiELj8FU9Cw8kPP5HeWUfGxCjlegdH3R ++FBtoQlDcQjYzO2uZR94Itg3yk3Dt+xbf7KxUsODwlgLj1UhV4eOXUDTosBFTrbTG ++v9gnRVH0Eyu9tF+CMUcCXhq6tnIrQOVv1ozcdXfIpk9gvIbfh4rlo6X0iM8Xge2t ++Vo7awq05t4wJBkO1xUtOaw9HabaszK/CU1iNV7cIBmaFF3AEP/KVfOs+kjubc9AF ++mqC+LVVClvJPNzm1YA5JZlxmQ0u1xXFqZv0OMoibgY+gSzaiAQz3eKB6vEv4Xv4U ++kaF9nEUTEjowpTE6uX9X0mGkXXT2wXmlTjosZFnxRX5IIrRNug30plRra5CNYPGp ++3uTmD/D7Nzi1iYitJg3yhrTQmCWiJY3x4Z0xophLkio2nlJ9WoTKf1AwTIATY7fa ++pX9bxEKldYXrYZNFlbqBPFgA/36v+JDVfMf2E9yRMCt0LAJ0HUM6zP0ngMv+S1TP ++Pu6X0WXR9JeuoaF4uJSty/xwdpST/CkHflFLVsk5n3tNQfWGjqoTSOJMgL9NRY9e ++Pc/OshHZHeCVFUSXtcf1pfmmBtT6FHX0L4cgVqA5xO8RYapnLDAFLXq2/dRv3NwW ++W9CzZcZKh7jmJw4iSIY5IU1+ThgugWoxlkcmjs/egjBclL8BBfqRIwx/vOE= + -----END RSA PRIVATE KEY----- +diff -urNad mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/t/openssl_1.test mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/t/openssl_1.test +--- mysql-dfsg-5.0-5.1.30really5.0.75~/mysql-test/t/openssl_1.test 2008-12-18 18:37:11.000000000 +0100 ++++ mysql-dfsg-5.0-5.1.30really5.0.75/mysql-test/t/openssl_1.test 2009-02-02 23:46:47.000000000 +0100 +@@ -11,8 +11,8 @@ + + grant select on test.* to ssl_user1@localhost require SSL; + grant select on test.* to ssl_user2@localhost require cipher "DHE-RSA-AES256-SHA"; +-grant select on test.* to ssl_user3@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com"; +-grant select on test.* to ssl_user4@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com" ISSUER "/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB"; ++grant select on test.* to ssl_user3@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "/C=SE/ST=Uppsala/O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com"; ++grant select on test.* to ssl_user4@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "/C=SE/ST=Uppsala/O=MySQL AB/emailAddress=abstract.mysql.developer@mysql.com" ISSUER "/C=SE/ST=Uppsala/L=Uppsala/O=MySQL AB"; + grant select on test.* to ssl_user5@localhost require cipher "DHE-RSA-AES256-SHA" AND SUBJECT "xxx"; + flush privileges; + diff -Nru /tmp/4LVtUT6EYc/mysql-dfsg-5.0-5.0.51a/debian/patches/93_debianupstream_reallyfix.dpatch /tmp/BTg1zmEllB/mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/patches/93_debianupstream_reallyfix.dpatch --- mysql-dfsg-5.0-5.0.51a/debian/patches/93_debianupstream_reallyfix.dpatch 1970-01-01 00:00:00.000000000 +0000 +++ mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/patches/93_debianupstream_reallyfix.dpatch 2009-08-04 14:49:34.000000000 +0000 @@ -0,0 +1,18 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 93_debianupstream_reallyfix.dpatch by Devendra Gera +## +## All lines beginning with `## DP:' are a description of the patch. +## DP: No description. + +@DPATCH@ +diff -urNad mysql-dfsg-5.0-5.0.51a~/configure.in mysql-dfsg-5.0-5.0.51a/configure.in +--- mysql-dfsg-5.0-5.0.51a~/configure.in 2009-08-04 11:31:45.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/configure.in 2009-08-04 11:32:09.000000000 +0000 +@@ -2998,7 +2998,6 @@ + cmd-line-utils/libedit/Makefile dnl + win/Makefile dnl + zlib/Makefile dnl +- debian/Makefile debian/defs.mk debian/control dnl + cmd-line-utils/readline/Makefile) + AC_CONFIG_COMMANDS([default], , test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h) + AC_OUTPUT diff -Nru /tmp/4LVtUT6EYc/mysql-dfsg-5.0-5.0.51a/debian/patches/93_sphinxse.dpatch /tmp/BTg1zmEllB/mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/patches/93_sphinxse.dpatch --- mysql-dfsg-5.0-5.0.51a/debian/patches/93_sphinxse.dpatch 1970-01-01 00:00:00.000000000 +0000 +++ mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/patches/93_sphinxse.dpatch 2009-08-04 14:51:16.000000000 +0000 @@ -0,0 +1,3591 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 93_sphinxse.dpatch by Devendra Gera +## +## All lines beginning with `## DP:' are a description of the patch. +## DP: No description. + +@DPATCH@ +diff -urNad mysql-dfsg-5.0-5.0.51a~/BUILD/SETUP.sh mysql-dfsg-5.0-5.0.51a/BUILD/SETUP.sh +--- mysql-dfsg-5.0-5.0.51a~/BUILD/SETUP.sh 2008-01-11 14:43:19.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/BUILD/SETUP.sh 2009-08-04 14:50:28.000000000 +0000 +@@ -60,9 +60,9 @@ + + c_warnings="$global_warnings -Wunused" + cxx_warnings="$global_warnings -Woverloaded-virtual -Wsign-promo -Wreorder -Wctor-dtor-privacy -Wnon-virtual-dtor" +-base_max_configs="--with-innodb --with-ndbcluster --with-archive-storage-engine --with-big-tables --with-blackhole-storage-engine --with-federated-storage-engine --with-csv-storage-engine $SSL_LIBRARY" +-base_max_no_ndb_configs="--with-innodb --without-ndbcluster --with-archive-storage-engine --with-big-tables --with-blackhole-storage-engine --with-federated-storage-engine --with-csv-storage-engine $SSL_LIBRARY" +-max_leave_isam_configs="--with-innodb --with-ndbcluster --with-archive-storage-engine --with-federated-storage-engine --with-blackhole-storage-engine --with-csv-storage-engine $SSL_LIBRARY --with-embedded-server --with-big-tables" ++base_max_configs="--with-innodb --with-ndbcluster --with-archive-storage-engine --with-big-tables --with-blackhole-storage-engine --with-federated-storage-engine --with-csv-storage-engine --with-sphinx-storage-engine $SSL_LIBRARY" ++base_max_no_ndb_configs="--with-innodb --without-ndbcluster --with-archive-storage-engine --with-big-tables --with-blackhole-storage-engine --with-federated-storage-engine --with-csv-storage-engine --with-sphinx-storage-engine $SSL_LIBRARY" ++max_leave_isam_configs="--with-innodb --with-ndbcluster --with-archive-storage-engine --with-federated-storage-engine --with-blackhole-storage-engine --with-csv-storage-engine --with-sphinx-storage-engine $SSL_LIBRARY --with-embedded-server --with-big-tables" + max_configs="$base_max_configs --with-embedded-server" + max_no_ndb_configs="$base_max_no_ndb_configs --with-embedded-server" + +diff -urNad mysql-dfsg-5.0-5.0.51a~/config/ac-macros/ha_sphinx.m4 mysql-dfsg-5.0-5.0.51a/config/ac-macros/ha_sphinx.m4 +--- mysql-dfsg-5.0-5.0.51a~/config/ac-macros/ha_sphinx.m4 1970-01-01 00:00:00.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/config/ac-macros/ha_sphinx.m4 2009-08-04 14:50:28.000000000 +0000 +@@ -0,0 +1,30 @@ ++dnl --------------------------------------------------------------------------- ++dnl Macro: MYSQL_CHECK_EXAMPLEDB ++dnl Sets HAVE_SPHINX_DB if --with-sphinx-storage-engine is used ++dnl --------------------------------------------------------------------------- ++AC_DEFUN([MYSQL_CHECK_SPHINXDB], [ ++ AC_ARG_WITH([sphinx-storage-engine], ++ [ ++ --with-sphinx-storage-engine ++ Enable the Sphinx Storage Engine], ++ [sphinxdb="$withval"], ++ [sphinxdb=no]) ++ AC_MSG_CHECKING([for example storage engine]) ++ ++ case "$sphinxdb" in ++ yes ) ++ AC_DEFINE([HAVE_SPHINX_DB], [1], [Builds Sphinx Engine]) ++ AC_MSG_RESULT([yes]) ++ [sphinxdb=yes] ++ ;; ++ * ) ++ AC_MSG_RESULT([no]) ++ [sphinxdb=no] ++ ;; ++ esac ++ ++]) ++dnl --------------------------------------------------------------------------- ++dnl END OF MYSQL_CHECK_EXAMPLE SECTION ++dnl --------------------------------------------------------------------------- ++ +diff -urNad mysql-dfsg-5.0-5.0.51a~/configure.in mysql-dfsg-5.0-5.0.51a/configure.in +--- mysql-dfsg-5.0-5.0.51a~/configure.in 2008-01-11 14:43:23.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/configure.in 2009-08-04 14:50:28.000000000 +0000 +@@ -48,6 +48,7 @@ + sinclude(config/ac-macros/ha_berkeley.m4) + sinclude(config/ac-macros/ha_blackhole.m4) + sinclude(config/ac-macros/ha_example.m4) ++sinclude(config/ac-macros/ha_sphinx.m4) + sinclude(config/ac-macros/ha_federated.m4) + sinclude(config/ac-macros/ha_innodb.m4) + sinclude(config/ac-macros/ha_ndbcluster.m4) +@@ -2574,6 +2575,7 @@ + MYSQL_CHECK_BDB + MYSQL_CHECK_INNODB + MYSQL_CHECK_EXAMPLEDB ++MYSQL_CHECK_SPHINXDB + MYSQL_CHECK_ARCHIVEDB + MYSQL_CHECK_CSVDB + MYSQL_CHECK_BLACKHOLEDB +diff -urNad mysql-dfsg-5.0-5.0.51a~/libmysqld/Makefile.am mysql-dfsg-5.0-5.0.51a/libmysqld/Makefile.am +--- mysql-dfsg-5.0-5.0.51a~/libmysqld/Makefile.am 2008-01-11 14:43:39.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/libmysqld/Makefile.am 2009-08-04 14:50:28.000000000 +0000 +@@ -29,6 +29,7 @@ + -I$(top_builddir)/include -I$(top_srcdir)/include \ + -I$(top_builddir)/sql -I$(top_srcdir)/sql \ + -I$(top_srcdir)/sql/examples \ ++ -I$(top_srcdir)/sql/sphinx \ + -I$(top_srcdir)/regex \ + $(openssl_includes) @ZLIB_INCLUDES@ + +@@ -39,6 +40,7 @@ + libmysqlsources = errmsg.c get_password.c libmysql.c client.c pack.c \ + my_time.c + sqlexamplessources = ha_example.cc ha_tina.cc ++sqlsphinxsources = ha_sphinx.cc + + noinst_HEADERS = embedded_priv.h emb_qcache.h + +@@ -67,7 +69,7 @@ + parse_file.cc sql_view.cc sql_trigger.cc my_decimal.cc \ + ha_blackhole.cc ha_archive.cc my_user.c + +-libmysqld_int_a_SOURCES= $(libmysqld_sources) $(libmysqlsources) $(sqlsources) $(sqlexamplessources) ++libmysqld_int_a_SOURCES= $(libmysqld_sources) $(libmysqlsources) $(sqlsources) $(sqlexamplessources) $(sqlsphinxsources) + libmysqld_a_SOURCES= + + # automake misses these +@@ -147,12 +149,16 @@ + rm -f $$f; \ + @LN_CP_F@ $(top_srcdir)/sql/examples/$$f $$f; \ + done; \ ++ for f in $(sqlsphinxsources); do \ ++ rm -f $$f; \ ++ @LN_CP_F@ $(top_srcdir)/sql/sphinx/$$f $$f; \ ++ done; \ + rm -f client_settings.h; \ + @LN_CP_F@ $(top_srcdir)/libmysql/client_settings.h client_settings.h + + + clean-local: +- rm -f `echo $(sqlsources) $(libmysqlsources) $(sqlexamplessources) | sed "s;\.lo;.c;g"` \ ++ rm -f `echo $(sqlsources) $(libmysqlsources) $(sqlexamplessources) $(sqlsphinxsources) | sed "s;\.lo;.c;g"` \ + $(top_srcdir)/linked_libmysqld_sources; \ + rm -f client_settings.h + +diff -urNad mysql-dfsg-5.0-5.0.51a~/mysql-test/r/ndb_basic.result mysql-dfsg-5.0-5.0.51a/mysql-test/r/ndb_basic.result +--- mysql-dfsg-5.0-5.0.51a~/mysql-test/r/ndb_basic.result 2008-01-11 15:23:39.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/mysql-test/r/ndb_basic.result 2009-08-04 14:51:10.000000000 +0000 +@@ -568,7 +568,7 @@ + insert into t1 values (1,1),(2,1),(3,1),(4,1),(5,2),(6,1),(7,1); + explain select * from t1 where a12345678901234567890123456789a1234567890=2; + id select_type table type possible_keys key key_len ref rows Extra +-1 SIMPLE t1 ref a12345678901234567890123456789a1234567890 a12345678901234567890123456789a1234567890 5 const 10 Using where ++1 SIMPLE t1 ref a12345678901234567890123456789a1234567890 a12345678901234567890123456789a1234567890 5 const 10 Using where with pushed condition + select * from t1 where a12345678901234567890123456789a1234567890=2; + a1234567890123456789012345678901234567890 a12345678901234567890123456789a1234567890 + 5 2 +diff -urNad mysql-dfsg-5.0-5.0.51a~/mysql-test/r/ps_1general.result mysql-dfsg-5.0-5.0.51a/mysql-test/r/ps_1general.result +--- mysql-dfsg-5.0-5.0.51a~/mysql-test/r/ps_1general.result 2008-01-11 15:23:40.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/mysql-test/r/ps_1general.result 2009-08-04 14:51:10.000000000 +0000 +@@ -329,6 +329,7 @@ + EXAMPLE YES/NO Example storage engine + ARCHIVE YES/NO Archive storage engine + CSV YES/NO CSV storage engine ++SPHINX YES/NO Sphinx storage engine 0.9.8 + ndbcluster YES/NO Clustered, fault-tolerant, memory-based tables + FEDERATED YES/NO Federated MySQL storage engine + MRG_MYISAM YES/NO Collection of identical MyISAM tables +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/Makefile.am mysql-dfsg-5.0-5.0.51a/sql/Makefile.am +--- mysql-dfsg-5.0-5.0.51a~/sql/Makefile.am 2008-01-11 14:43:37.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/Makefile.am 2009-08-04 14:50:31.000000000 +0000 +@@ -68,6 +68,7 @@ + sql_array.h sql_cursor.h \ + examples/ha_example.h ha_archive.h \ + examples/ha_tina.h ha_blackhole.h \ ++ sphinx/ha_sphinx.h \ + ha_federated.h + mysqld_SOURCES = sql_lex.cc sql_handler.cc \ + item.cc item_sum.cc item_buff.cc item_func.cc \ +@@ -105,6 +106,7 @@ + sp_cache.cc parse_file.cc sql_trigger.cc \ + examples/ha_example.cc ha_archive.cc \ + examples/ha_tina.cc ha_blackhole.cc \ ++ sphinx/ha_sphinx.cc \ + ha_federated.cc + + gen_lex_hash_SOURCES = gen_lex_hash.cc +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/handler.cc mysql-dfsg-5.0-5.0.51a/sql/handler.cc +--- mysql-dfsg-5.0-5.0.51a~/sql/handler.cc 2008-01-11 14:43:23.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/handler.cc 2009-08-04 14:50:31.000000000 +0000 +@@ -77,6 +77,15 @@ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + HTON_NO_FLAGS }; + #endif ++#ifdef HAVE_SPHINX_DB ++#include "sphinx/ha_sphinx.h" ++extern handlerton sphinx_hton; ++#else ++handlerton sphinx_hton = { "SPHINX", SHOW_OPTION_NO, "SPHINX storage engine", ++ DB_TYPE_SPHINX_DB, NULL, 0, 0, NULL, NULL, ++ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, ++ HTON_NO_FLAGS }; ++#endif + #ifdef HAVE_INNOBASE_DB + #include "ha_innodb.h" + extern handlerton innobase_hton; +@@ -141,6 +150,7 @@ + &example_hton, + &archive_hton, + &tina_hton, ++ &sphinx_hton, + &ndbcluster_hton, + &federated_hton, + &myisammrg_hton, +@@ -341,6 +351,12 @@ + return new (alloc) ha_tina(table); + return NULL; + #endif ++#ifdef HAVE_SPHINX_DB ++ case DB_TYPE_SPHINX_DB: ++ if (have_sphinx_db == SHOW_OPTION_YES) ++ return new (alloc) ha_sphinx(table); ++ return NULL; ++#endif + #ifdef HAVE_NDBCLUSTER_DB + case DB_TYPE_NDBCLUSTER: + if (have_ndbcluster == SHOW_OPTION_YES) +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/handler.h mysql-dfsg-5.0-5.0.51a/sql/handler.h +--- mysql-dfsg-5.0-5.0.51a~/sql/handler.h 2008-01-11 14:43:28.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/handler.h 2009-08-04 14:50:32.000000000 +0000 +@@ -186,8 +186,9 @@ + DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB, + DB_TYPE_GEMINI, DB_TYPE_NDBCLUSTER, + DB_TYPE_EXAMPLE_DB, DB_TYPE_ARCHIVE_DB, DB_TYPE_CSV_DB, +- DB_TYPE_FEDERATED_DB, ++ DB_TYPE_FEDERATED_DB, + DB_TYPE_BLACKHOLE_DB, ++ DB_TYPE_SPHINX_DB, + DB_TYPE_DEFAULT // Must be last + }; + +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/mysql_priv.h mysql-dfsg-5.0-5.0.51a/sql/mysql_priv.h +--- mysql-dfsg-5.0-5.0.51a~/sql/mysql_priv.h 2008-01-11 14:43:38.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/mysql_priv.h 2009-08-04 14:50:32.000000000 +0000 +@@ -1408,6 +1408,12 @@ + #else + extern SHOW_COMP_OPTION have_csv_db; + #endif ++#ifdef HAVE_SPHINX_DB ++extern handlerton sphinx_hton; ++#define have_sphinx_db sphinx_hton.state ++#else ++extern SHOW_COMP_OPTION have_sphinx_db; ++#endif + #ifdef HAVE_FEDERATED_DB + extern handlerton federated_hton; + #define have_federated_db federated_hton.state +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/mysqld.cc mysql-dfsg-5.0-5.0.51a/sql/mysqld.cc +--- mysql-dfsg-5.0-5.0.51a~/sql/mysqld.cc 2008-01-11 14:43:18.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/mysqld.cc 2009-08-04 14:50:32.000000000 +0000 +@@ -6688,6 +6688,11 @@ + #else + have_csv_db= SHOW_OPTION_NO; + #endif ++#ifdef HAVE_SPHINX_DB ++ have_sphinx_db= SHOW_OPTION_YES; ++#else ++ have_sphinx_db= SHOW_OPTION_NO; ++#endif + #ifdef HAVE_NDBCLUSTER_DB + have_ndbcluster=SHOW_OPTION_DISABLED; + #else +@@ -7780,6 +7785,7 @@ + #undef have_example_db + #undef have_archive_db + #undef have_csv_db ++#undef have_sphinx_db + #undef have_federated_db + #undef have_partition_db + #undef have_blackhole_db +@@ -7790,6 +7796,7 @@ + SHOW_COMP_OPTION have_example_db= SHOW_OPTION_NO; + SHOW_COMP_OPTION have_archive_db= SHOW_OPTION_NO; + SHOW_COMP_OPTION have_csv_db= SHOW_OPTION_NO; ++SHOW_COMP_OPTION have_sphinx_db= SHOW_OPTION_NO; + SHOW_COMP_OPTION have_federated_db= SHOW_OPTION_NO; + SHOW_COMP_OPTION have_partition_db= SHOW_OPTION_NO; + SHOW_COMP_OPTION have_blackhole_db= SHOW_OPTION_NO; +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/set_var.cc mysql-dfsg-5.0-5.0.51a/sql/set_var.cc +--- mysql-dfsg-5.0-5.0.51a~/sql/set_var.cc 2008-01-11 14:43:29.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/set_var.cc 2009-08-04 14:50:32.000000000 +0000 +@@ -882,6 +882,7 @@ + {"have_compress", (char*) &have_compress, SHOW_HAVE}, + {"have_crypt", (char*) &have_crypt, SHOW_HAVE}, + {"have_csv", (char*) &have_csv_db, SHOW_HAVE}, ++ {"have_sphinx", (char*) &have_sphinx_db, SHOW_HAVE}, + {"have_dynamic_loading", (char*) &have_dlopen, SHOW_HAVE}, + {"have_example_engine", (char*) &have_example_db, SHOW_HAVE}, + {"have_federated_engine", (char*) &have_federated_db, SHOW_HAVE}, +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sphinx/CMakeLists.txt mysql-dfsg-5.0-5.0.51a/sql/sphinx/CMakeLists.txt +--- mysql-dfsg-5.0-5.0.51a~/sql/sphinx/CMakeLists.txt 1970-01-01 00:00:00.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sphinx/CMakeLists.txt 2009-08-04 14:50:32.000000000 +0000 +@@ -0,0 +1,11 @@ ++SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DSAFEMALLOC -DSAFE_MUTEX") ++SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DSAFEMALLOC -DSAFE_MUTEX") ++ADD_DEFINITIONS(-DMYSQL_SERVER) ++ ++INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include ++ ${CMAKE_SOURCE_DIR}/sql ++ ${CMAKE_SOURCE_DIR}/extra/yassl/include ++ ${CMAKE_SOURCE_DIR}/regex) ++ ++SET(SPHINX_SOURCES ha_sphinx.cc) ++ADD_LIBRARY(sphinx ha_sphinx.cc) +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sphinx/HOWTO.txt mysql-dfsg-5.0-5.0.51a/sql/sphinx/HOWTO.txt +--- mysql-dfsg-5.0-5.0.51a~/sql/sphinx/HOWTO.txt 1970-01-01 00:00:00.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sphinx/HOWTO.txt 2009-08-04 14:50:32.000000000 +0000 +@@ -0,0 +1,181 @@ ++1. Prepare MySQL source tree ++ 5.0 ++ There are two options: ++ a) ++ - Download sources of mysql-5.0.22.tar.gz from dev.mysql.com site. ++ - Copy patch file sphinx.5.0.22.diff into source directory and run ++ patch -p1 < sphinx.5.0.22.diff ++ - run BUILD/autorun.sh ++ - make dir sql/sphinx and place files from sphinx-se.tar.gz here ++ b) ++ - Download prepared sources from sphinxsearch.com site ++ mysql-5.0.22-sphinx.tar.gz ++ ++ 5.1 ( only 5.1.12 or later are supported ) ++ - place files from sphinx-se.tar.gz into storage/sphinx dir ++ ++2. Compile mysql ++ ++ - Use configure for 5.0: --with-sphinx-storage-engine option ++ for 5.1: --with-plugins=sphinx ++ ++ - See detailed info on http://dev.mysql.com/doc/refman/5.0/en/installing-source.html ++ - I usually use: ++ ++CFLAGS="-g -O2 -fno-omit-frame-pointer" CXX="gcc" \ ++CXXFLAGS="-g -felide-constructors -fno-exceptions -fno-rtti -O2 -fno-omit-frame-pointer" \ ++CXXLDFLAGS="" \ ++./configure --prefix=/usr/local/mysql-5-sphinx \ ++ --enable-assembler \ ++ --with-extra-charsets=complex \ ++ --enable-thread-safe-client \ ++ --with-readline \ ++ --with-big-tables \ ++ --enable-local-infile \ ++ --with-sphinx-storage-engine (--with-plugins=sphinx in 5.1) ++ ++gmake -j4 ++ ++3. Check installation ++ - run mysql client ++ - execute SHOW ENGINES; ++ You should see something like: ++ ++mysql> show engines; +++------------+----------+----------------------------------------------------------------+ ++| Engine | Support | Comment | +++------------+----------+----------------------------------------------------------------+ ++| MyISAM | DEFAULT | Default engine as of MySQL 3.23 with great performance | ++ ... ++| SPHINX | YES | Sphinx storage engine | ++ ... +++------------+----------+----------------------------------------------------------------+ ++13 rows in set (0.00 sec) ++ ++ if you see SPHINX - YES, mysql is ready to use sphinx storage engine ++ ++4. Create SPHINX table: ++ ++ CREATE TABLE t1 (id INT, gid INT, doctime TIMESTAMP, weigth INT, search VARCHAR(255) NOT NULL, KEY qidx (search)) ++ ENGINE=SPHINX ++ CONNECTION="sphinx://localhost:3312/myindex"; ++ ++ This statement declares table will access to sphinx daemon on localhost:3312 and will use index "myindex". ++ ++ Table name doesn't matter, you can use any allowed; ++ Column names doesn't matter, you can use any allowed; ++ Column types are IMPORTANT especially 3rd column must be TIMESTAMP, and 5th column must be VARCHAR; ++ KEY on 5th column is mandatory; ++ ++ CONNECTION string: ++ "sphinx://HOST:PORT/INDEXNAME" ++ sphinx storage engine will try to connect to sphinx deamon on HOST:PORT and use index INDEXNAME; ++ if you skip CONNECTION option - default value is 127.0.0.1:3312/* ++ ++ You can change the connection params later by command ++ ++ ALTER TABLE t1 CONNECTION="sphinx://NEW_HOST:NEW_PORT/INDEXNAME"; ++ ++ ++5. Query to sphinx daemon ++ You should always lookup sphix table by key, typically joining it ++ with indexed documents table , like: ++ ++ ++ SELECT [columnt_list] FROM test.documents docs JOIN t1 fs ON (docs.id=fs.id) ++ WHERE query="query_string"; ++ ++ ++ query_string has format: ++ ++ "param1=value;param2=value;param3=value;..."; ++ ++ Available params: ++ query - text of query ++ mode - search mode; all - MATCH_ALL (default) ; any - MATCH_ANY; phrase - MATCH_PHRASE; boolean - MATCH_BOOLEAN ++ sort - sort mode; 0 - RELEVANCE (default) ; 1 - DATE DESC; 2 - DATE ASC; 3 - TIME SEGMENTS ++ limit - limit of output records (default 20) ++ offset - start from record from offset (default 0) ++ index - name of index or * (default) ++ minid / maxid - limits for id ++ min_ts / max_ts - minimal and maximal timestamp ++ min_gid / max_gid - minimal and maxumal group id ++ groups - list of groups for lookup (formar groups=1,3,4,56) ++ weights - use this weights for columns (format weights=1,10,4) ++ ++ only query field is mandatory, so simplest query_string is ++ ++ search="query=sphinx" or even search="sphinx" ++ ++ more complex examples: ++ ++ search="sphinx mysql;mode=any" - match any of words ++ search="sphinx oracle;offset=100;limit=50"; - fetch result starting with offset 100 and limit count of records = 50 ++ search="sphinx postgresql;groups=1,4,5;index=test1;" - search only in groups 1,4,5 in index test1 ++ search="sphinx & postgresql | (soft & java);mode=boolean" - boolean search ++ ++ ++ example output: ++ ++mysql> select * from t1 where query="document;index=test1"; +++------+------+---------------------+--------+----------------------+ ++| id | gid | docdate | weight | query | +++------+------+---------------------+--------+----------------------+ ++| 2 | 1 | 2006-05-13 07:39:02 | 1 | document;index=test1 | ++| 1 | 1 | 2006-05-13 07:39:02 | 1 | document;index=test1 | +++------+------+---------------------+--------+----------------------+ ++2 rows in set (0.00 sec) ++ ++After executed query additinal info available by command: ++SHOW ENGINE SPHINX STATUS: ++ ++mysql> show engine sphinx status; +++--------+-------+-------------------------------------------------+ ++| Type | Name | Status | +++--------+-------+-------------------------------------------------+ ++| SPHINX | stats | total: 25, total found: 25, time: 126, words: 2 | ++| SPHINX | words | sphinx:591:1256 soft:11076:15945 | +++--------+-------+-------------------------------------------------+ ++2 rows in set (0.00 sec) ++ ++6. Example with JOIN. ++ Assuming you have table "documents" from example.sql, and table fulltextsearch with SPHINX engine; ++ ++mysql> SELECT content,docdate FROM test.documents docs JOIN fulltextsearch fs ON (docs.id=fs.id) ++ WHERE query="one document;mode=any"; ++ +++-------------------------------------+---------------------+ ++| content | docdate | +++-------------------------------------+---------------------+ ++| this is my test document number two | 2006-06-17 14:04:28 | ++| this is my test document number one | 2006-06-17 14:04:28 | +++-------------------------------------+---------------------+ ++2 rows in set (0.00 sec) ++ ++mysql> show engine sphinx status; +++--------+-------+---------------------------------------------+ ++| Type | Name | Status | +++--------+-------+---------------------------------------------+ ++| SPHINX | stats | total: 2, total found: 2, time: 0, words: 2 | ++| SPHINX | words | one:1:2 document:2:2 | +++--------+-------+---------------------------------------------+ ++2 rows in set (0.00 sec) ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sphinx/Makefile.am mysql-dfsg-5.0-5.0.51a/sql/sphinx/Makefile.am +--- mysql-dfsg-5.0-5.0.51a~/sql/sphinx/Makefile.am 1970-01-01 00:00:00.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sphinx/Makefile.am 2009-08-04 14:50:32.000000000 +0000 +@@ -0,0 +1,54 @@ ++# Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program; if not, write to the Free Software ++# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ ++#called from the top level Makefile ++ ++MYSQLDATAdir = $(localstatedir) ++MYSQLSHAREdir = $(pkgdatadir) ++MYSQLBASEdir= $(prefix) ++MYSQLLIBdir= $(pkglibdir) ++INCLUDES = -I$(top_srcdir)/include -I$(top_builddir)/include \ ++ -I$(top_srcdir)/regex \ ++ -I$(top_srcdir)/sql \ ++ -I$(srcdir) ++SUBDIRS = ../../include ../../mysys ../../strings ../../dbug ../../extra ++WRAPLIBS= ++ ++LDADD = ++ ++DEFS= @DEFS@ \ ++ -D_REENTRANT -D_PTHREADS -DENGINE -DSTORAGE_ENGINE -DMYSQL_SERVER ++ ++noinst_HEADERS = ha_sphinx.h ++ ++EXTRA_LTLIBRARIES = ha_sphinx.la ++pkglib_LTLIBRARIES = @plugin_sphinx_shared_target@ ++ha_sphinx_la_LDFLAGS = -module -rpath $(MYSQLLIBdir) ++ha_sphinx_la_CXXFLAGS= $(AM_CFLAGS) -DMYSQL_DYNAMIC_PLUGIN ++ha_sphinx_la_CFLAGS = $(AM_CFLAGS) -DMYSQL_DYNAMIC_PLUGIN ++ha_sphinx_la_SOURCES = ha_sphinx.cc ++ ++ ++EXTRA_LIBRARIES = libsphinx.a ++noinst_LIBRARIES = @plugin_sphinx_static_target@ ++libsphinx_a_CXXFLAGS = $(AM_CFLAGS) ++libsphinx_a_CFLAGS = $(AM_CFLAGS) ++libsphinx_a_SOURCES= ha_sphinx.cc ++ ++ ++EXTRA_DIST = cmakelists.txt ++# Don't update the files from bitkeeper ++%::SCCS/s.% +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sphinx/gen_data.php mysql-dfsg-5.0-5.0.51a/sql/sphinx/gen_data.php +--- mysql-dfsg-5.0-5.0.51a~/sql/sphinx/gen_data.php 1970-01-01 00:00:00.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sphinx/gen_data.php 2009-08-04 14:50:32.000000000 +0000 +@@ -0,0 +1,37 @@ ++ +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sphinx/ha_sphinx.cc mysql-dfsg-5.0-5.0.51a/sql/sphinx/ha_sphinx.cc +--- mysql-dfsg-5.0-5.0.51a~/sql/sphinx/ha_sphinx.cc 1970-01-01 00:00:00.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sphinx/ha_sphinx.cc 2009-08-04 14:50:32.000000000 +0000 +@@ -0,0 +1,2788 @@ ++// ++// $Id: ha_sphinx.cc 1200 2008-03-06 20:03:07Z shodan $ ++// ++ ++#ifdef USE_PRAGMA_IMPLEMENTATION ++#pragma implementation // gcc: Class implementation ++#endif ++ ++#if _MSC_VER>=1400 ++#define _CRT_SECURE_NO_DEPRECATE 1 ++#define _CRT_NONSTDC_NO_DEPRECATE 1 ++#endif ++ ++#include ++ ++#if MYSQL_VERSION_ID>50100 ++#include "mysql_priv.h" ++#include ++#else ++#include "../mysql_priv.h" ++#endif ++ ++#include ++#include ++ ++#ifndef __WIN__ ++ // UNIX-specific ++ #include ++ #include ++ ++ #define RECV_FLAGS MSG_WAITALL ++#else ++ // Windows-specific ++ #include ++ #define strcasecmp stricmp ++ #define snprintf _snprintf ++ ++ #define RECV_FLAGS 0 ++#endif ++ ++#include ++#include "ha_sphinx.h" ++ ++#ifndef MSG_WAITALL ++#define MSG_WAITALL 0 ++#endif ++ ++#if _MSC_VER>=1400 ++#pragma warning(push,4) ++#endif ++ ++///////////////////////////////////////////////////////////////////////////// ++ ++/// there might be issues with min() on different platforms (eg. Gentoo, they say) ++#define Min(a,b) ((a)<(b)?(a):(b)) ++ ++/// unaligned RAM accesses are forbidden on SPARC ++#if defined(sparc) || defined(__sparc__) ++#define UNALIGNED_RAM_ACCESS 0 ++#else ++#define UNALIGNED_RAM_ACCESS 1 ++#endif ++ ++ ++#if UNALIGNED_RAM_ACCESS ++ ++/// pass-through wrapper ++template < typename T > inline T sphUnalignedRead ( const T & tRef ) ++{ ++ return tRef; ++} ++ ++/// pass-through wrapper ++template < typename T > void sphUnalignedWrite ( void * pPtr, const T & tVal ) ++{ ++ *(T*)pPtr = tVal; ++} ++ ++#else ++ ++/// unaligned read wrapper for some architectures (eg. SPARC) ++template < typename T > ++inline T sphUnalignedRead ( const T & tRef ) ++{ ++ T uTmp; ++ byte * pSrc = (byte *) &tRef; ++ byte * pDst = (byte *) &uTmp; ++ for ( int i=0; i<(int)sizeof(T); i++ ) ++ *pDst++ = *pSrc++; ++ return uTmp; ++} ++ ++/// unaligned write wrapper for some architectures (eg. SPARC) ++template < typename T > ++void sphUnalignedWrite ( void * pPtr, const T & tVal ) ++{ ++ byte * pDst = (byte *) pPtr; ++ byte * pSrc = (byte *) &tVal; ++ for ( int i=0; i<(int)sizeof(T); i++ ) ++ *pDst++ = *pSrc++; ++} ++ ++#endif ++ ++///////////////////////////////////////////////////////////////////////////// ++ ++// FIXME! make this all dynamic ++#define SPHINXSE_MAX_FILTERS 32 ++ ++#define SPHINXSE_DEFAULT_HOST "127.0.0.1" ++#define SPHINXSE_DEFAULT_PORT 3312 ++#define SPHINXSE_DEFAULT_INDEX "*" ++ ++#define SPHINXSE_SYSTEM_COLUMNS 3 ++ ++#define SPHINXSE_MAX_ALLOC (16*1024*1024) ++#define SPHINXSE_MAX_KEYWORDSTATS 4096 ++ ++// FIXME! all the following is cut-n-paste from sphinx.h and searchd.cpp ++#define SPHINX_VERSION "0.9.8" ++ ++enum ++{ ++ SPHINX_SEARCHD_PROTO = 1, ++ SEARCHD_COMMAND_SEARCH = 0, ++ VER_COMMAND_SEARCH = 0x113, ++}; ++ ++/// search query sorting orders ++enum ESphSortOrder ++{ ++ SPH_SORT_RELEVANCE = 0, ///< sort by document relevance desc, then by date ++ SPH_SORT_ATTR_DESC = 1, ///< sort by document date desc, then by relevance desc ++ SPH_SORT_ATTR_ASC = 2, ///< sort by document date asc, then by relevance desc ++ SPH_SORT_TIME_SEGMENTS = 3, ///< sort by time segments (hour/day/week/etc) desc, then by relevance desc ++ SPH_SORT_EXTENDED = 4, ///< sort by SQL-like expression (eg. "@relevance DESC, price ASC, @id DESC") ++ SPH_SORT_EXPR = 5, ///< sort by expression ++ ++ SPH_SORT_TOTAL ++}; ++ ++/// search query matching mode ++enum ESphMatchMode ++{ ++ SPH_MATCH_ALL = 0, ///< match all query words ++ SPH_MATCH_ANY, ///< match any query word ++ SPH_MATCH_PHRASE, ///< match this exact phrase ++ SPH_MATCH_BOOLEAN, ///< match this boolean query ++ SPH_MATCH_EXTENDED, ///< match this extended query ++ SPH_MATCH_FULLSCAN, ///< match all document IDs w/o fulltext query, apply filters ++ SPH_MATCH_EXTENDED2, ///< extended engine V2 (TEMPORARY, WILL BE REMOVED IN 0.9.8-RELEASE) ++ ++ SPH_MATCH_TOTAL ++}; ++ ++/// search query relevance ranking mode ++enum ESphRankMode ++{ ++ SPH_RANK_PROXIMITY_BM25 = 0, ///< default mode, phrase proximity major factor and BM25 minor one ++ SPH_RANK_BM25 = 1, ///< statistical mode, BM25 ranking only (faster but worse quality) ++ SPH_RANK_NONE = 2, ///< no ranking, all matches get a weight of 1 ++ SPH_RANK_WORDCOUNT = 3, ///< simple word-count weighting, rank is a weighted sum of per-field keyword occurence counts ++ ++ SPH_RANK_TOTAL, ++ SPH_RANK_DEFAULT = SPH_RANK_PROXIMITY_BM25 ++}; ++ ++/// search query grouping mode ++enum ESphGroupBy ++{ ++ SPH_GROUPBY_DAY = 0, ///< group by day ++ SPH_GROUPBY_WEEK = 1, ///< group by week ++ SPH_GROUPBY_MONTH = 2, ///< group by month ++ SPH_GROUPBY_YEAR = 3, ///< group by year ++ SPH_GROUPBY_ATTR = 4 ///< group by attribute value ++}; ++ ++/// known attribute types ++enum ++{ ++ SPH_ATTR_NONE = 0, ///< not an attribute at all ++ SPH_ATTR_INTEGER = 1, ///< this attr is just an integer ++ SPH_ATTR_TIMESTAMP = 2, ///< this attr is a timestamp ++ SPH_ATTR_ORDINAL = 3, ///< this attr is an ordinal string number (integer at search time, specially handled at indexing time) ++ SPH_ATTR_BOOL = 4, ///< this attr is a boolean bit field ++ SPH_ATTR_FLOAT = 5, ++ ++ SPH_ATTR_MULTI = 0x40000000UL ///< this attr has multiple values (0 or more) ++}; ++ ++/// known answers ++enum ++{ ++ SEARCHD_OK = 0, ///< general success, command-specific reply follows ++ SEARCHD_ERROR = 1, ///< general failure, error message follows ++ SEARCHD_RETRY = 2, ///< temporary failure, error message follows, client should retry later ++ SEARCHD_WARNING = 3 ///< general success, warning message and command-specific reply follow ++}; ++ ++////////////////////////////////////////////////////////////////////////////// ++ ++#define SPHINX_DEBUG_OUTPUT 0 ++#define SPHINX_DEBUG_CALLS 0 ++ ++#include ++ ++#if SPHINX_DEBUG_OUTPUT ++inline void SPH_DEBUG ( const char * format, ... ) ++{ ++ va_list ap; ++ va_start ( ap, format ); ++ fprintf ( stderr, "SphinxSE: " ); ++ vfprintf ( stderr, format, ap ); ++ fprintf ( stderr, "\n" ); ++ va_end ( ap ); ++} ++#else ++inline void SPH_DEBUG ( const char *, ... ) {} ++#endif ++ ++#if SPHINX_DEBUG_CALLS ++ ++#define SPH_ENTER_FUNC() { SPH_DEBUG ( "enter %s", __FUNCTION__ ); } ++#define SPH_ENTER_METHOD() { SPH_DEBUG ( "enter %s(this=%08x)", __FUNCTION__, this ); } ++#define SPH_RET(_arg) { SPH_DEBUG ( "leave %s", __FUNCTION__ ); return _arg; } ++#define SPH_VOID_RET() { SPH_DEBUG ( "leave %s", __FUNCTION__ ); return; } ++ ++#else ++ ++#define SPH_ENTER_FUNC() ++#define SPH_ENTER_METHOD() ++#define SPH_RET(_arg) { return(_arg); } ++#define SPH_VOID_RET() { return; } ++ ++#endif ++ ++ ++#define SafeDelete(_arg) { if ( _arg ) delete ( _arg ); (_arg) = NULL; } ++#define SafeDeleteArray(_arg) { if ( _arg ) delete [] ( _arg ); (_arg) = NULL; } ++ ++////////////////////////////////////////////////////////////////////////////// ++ ++/// a structure that will be shared among all open Sphinx SE handlers ++struct CSphSEShare ++{ ++ pthread_mutex_t m_tMutex; ++ THR_LOCK m_tLock; ++ ++ char * m_sTable; ++ char * m_sScheme; ++ char * m_sHost; ///< points into m_sScheme buffer, DO NOT FREE EXPLICITLY ++ char * m_sSocket; ///< points into m_sScheme buffer, DO NOT FREE EXPLICITLY ++ char * m_sIndex; ///< points into m_sScheme buffer, DO NOT FREE EXPLICITLY ++ ushort m_iPort; ++ uint m_iTableNameLen; ++ uint m_iUseCount; ++ CHARSET_INFO * m_pTableQueryCharset; ++ ++ int m_iTableFields; ++ char ** m_sTableField; ++ enum_field_types * m_eTableFieldType; ++ ++ CSphSEShare () ++ : m_sTable ( NULL ) ++ , m_sScheme ( NULL ) ++ , m_sHost ( NULL ) ++ , m_sSocket ( NULL ) ++ , m_sIndex ( NULL ) ++ , m_iPort ( 0 ) ++ , m_iTableNameLen ( 0 ) ++ , m_iUseCount ( 1 ) ++ , m_pTableQueryCharset ( NULL ) ++ ++ , m_iTableFields ( 0 ) ++ , m_sTableField ( NULL ) ++ , m_eTableFieldType ( NULL ) ++ { ++ thr_lock_init ( &m_tLock ); ++ pthread_mutex_init ( &m_tMutex, MY_MUTEX_INIT_FAST ); ++ } ++ ++ ~CSphSEShare () ++ { ++ pthread_mutex_destroy ( &m_tMutex ); ++ thr_lock_delete ( &m_tLock ); ++ ++ SafeDeleteArray ( m_sTable ); ++ SafeDeleteArray ( m_sScheme ); ++ ResetTable (); ++ } ++ ++ void ResetTable () ++ { ++ for ( int i=0; i50100 ++ ++#if MYSQL_VERSION_ID<50114 ++#error Sphinx SE requires MySQL 5.1.14 or higher if compiling for 5.1.x series! ++#endif ++ ++static handler * sphinx_create_handler ( handlerton * hton, TABLE_SHARE * table, MEM_ROOT * mem_root ); ++static int sphinx_init_func ( void * p ); ++static int sphinx_close_connection ( handlerton * hton, THD * thd ); ++static int sphinx_panic ( handlerton * hton, enum ha_panic_function flag ); ++static bool sphinx_show_status ( handlerton * hton, THD * thd, stat_print_fn * stat_print, enum ha_stat_type stat_type ); ++ ++#else ++ ++static bool sphinx_init_func_for_handlerton (); ++static int sphinx_close_connection ( THD * thd ); ++bool sphinx_show_status ( THD * thd ); ++ ++#endif // >50100 ++ ++////////////////////////////////////////////////////////////////////////////// ++ ++static const char sphinx_hton_name[] = "SPHINX"; ++static const char sphinx_hton_comment[] = "Sphinx storage engine " SPHINX_VERSION; ++ ++#if MYSQL_VERSION_ID<50100 ++handlerton sphinx_hton = ++{ ++ #ifdef MYSQL_HANDLERTON_INTERFACE_VERSION ++ MYSQL_HANDLERTON_INTERFACE_VERSION, ++ #endif ++ sphinx_hton_name, ++ SHOW_OPTION_YES, ++ sphinx_hton_comment, ++ DB_TYPE_SPHINX_DB, ++ sphinx_init_func_for_handlerton, ++ 0, // slot ++ 0, // savepoint size ++ sphinx_close_connection, // close_connection ++ NULL, // savepoint ++ NULL, // rollback to savepoint ++ NULL, // release savepoint ++ NULL, // commit ++ NULL, // rollback ++ NULL, // prepare ++ NULL, // recover ++ NULL, // commit_by_xid ++ NULL, // rollback_by_xid ++ NULL, // create_cursor_read_view ++ NULL, // set_cursor_read_view ++ NULL, // close_cursor_read_view ++ HTON_CAN_RECREATE ++}; ++#endif ++ ++////////////////////////////////////////////////////////////////////////////// ++ ++// variables for Sphinx shared methods ++pthread_mutex_t sphinx_mutex; // mutex to init the hash ++static int sphinx_init = 0; // flag whether the hash was initialized ++static HASH sphinx_open_tables; // hash used to track open tables ++ ++////////////////////////////////////////////////////////////////////////////// ++// INITIALIZATION AND SHUTDOWN ++////////////////////////////////////////////////////////////////////////////// ++ ++// hashing function ++#if MYSQL_VERSION_ID>=50120 ++typedef size_t GetKeyLength_t; ++#else ++typedef uint GetKeyLength_t; ++#endif ++ ++static byte * sphinx_get_key ( const byte * pSharePtr, GetKeyLength_t * pLength, my_bool ) ++{ ++ CSphSEShare * pShare = (CSphSEShare *) pSharePtr; ++ *pLength = (size_t) pShare->m_iTableNameLen; ++ return (byte*) pShare->m_sTable; ++} ++ ++#if MYSQL_VERSION_ID<50100 ++static int sphinx_init_func ( void * ) // to avoid unused arg warning ++#else ++static int sphinx_init_func ( void * p ) ++#endif ++{ ++ SPH_ENTER_FUNC(); ++ if ( !sphinx_init ) ++ { ++ sphinx_init = 1; ++ VOID ( pthread_mutex_init ( &sphinx_mutex, MY_MUTEX_INIT_FAST ) ); ++ hash_init ( &sphinx_open_tables, system_charset_info, 32, 0, 0, ++ sphinx_get_key, 0, 0 ); ++ ++ #if MYSQL_VERSION_ID > 50100 ++ handlerton * hton = (handlerton*) p; ++ hton->state = SHOW_OPTION_YES; ++ hton->db_type = DB_TYPE_DEFAULT; ++ hton->create = sphinx_create_handler; ++ hton->close_connection = sphinx_close_connection; ++ hton->show_status = sphinx_show_status; ++ hton->panic = sphinx_panic; ++ hton->flags = HTON_CAN_RECREATE; ++ #endif ++ } ++ SPH_RET(0); ++} ++ ++ ++#if MYSQL_VERSION_ID<50100 ++static bool sphinx_init_func_for_handlerton () ++{ ++ return sphinx_init_func ( &sphinx_hton ); ++} ++#endif ++ ++ ++#if MYSQL_VERSION_ID>50100 ++ ++static int sphinx_close_connection ( handlerton * hton, THD * thd ) ++{ ++ // deallocate common handler data ++ SPH_ENTER_FUNC(); ++ void ** tmp = thd_ha_data ( thd, hton ); ++ CSphSEThreadData * pTls = (CSphSEThreadData*) (*tmp); ++ SafeDelete ( pTls ); ++ *tmp = NULL; ++ SPH_RET(0); ++} ++ ++ ++static int sphinx_done_func ( void * ) ++{ ++ SPH_ENTER_FUNC(); ++ ++ int error = 0; ++ if ( sphinx_init ) ++ { ++ sphinx_init = 0; ++ if ( sphinx_open_tables.records ) ++ error = 1; ++ hash_free ( &sphinx_open_tables ); ++ pthread_mutex_destroy ( &sphinx_mutex ); ++ } ++ ++ SPH_RET(0); ++} ++ ++ ++static int sphinx_panic ( handlerton * hton, enum ha_panic_function ) ++{ ++ return sphinx_done_func ( hton ); ++} ++ ++#else ++ ++static int sphinx_close_connection ( THD * thd ) ++{ ++ // deallocate common handler data ++ SPH_ENTER_FUNC(); ++ CSphSEThreadData * pTls = (CSphSEThreadData*) thd->ha_data[sphinx_hton.slot]; ++ SafeDelete ( pTls ); ++ thd->ha_data[sphinx_hton.slot] = NULL; ++ SPH_RET(0); ++} ++ ++#endif // >50100 ++ ++////////////////////////////////////////////////////////////////////////////// ++// SHOW STATUS ++////////////////////////////////////////////////////////////////////////////// ++ ++#if MYSQL_VERSION_ID>50100 ++static bool sphinx_show_status ( handlerton * hton, THD * thd, stat_print_fn * stat_print, ++ enum ha_stat_type ) ++#else ++bool sphinx_show_status ( THD * thd ) ++#endif ++{ ++ SPH_ENTER_FUNC(); ++ ++#if MYSQL_VERSION_ID<50100 ++ Protocol * protocol = thd->protocol; ++ List field_list; ++#endif ++ ++ char buf1[IO_SIZE]; ++ uint buf1len; ++ char buf2[IO_SIZE]; ++ uint buf2len= 0; ++ String words; ++ ++ buf1[0] = '\0'; ++ buf2[0] = '\0'; ++ ++#if MYSQL_VERSION_ID>50100 ++ CSphSEThreadData * pTls = (CSphSEThreadData*) ( *thd_ha_data ( thd, hton ) ); ++#else ++ if ( have_sphinx_db!=SHOW_OPTION_YES ) ++ { ++ my_message ( ER_NOT_SUPPORTED_YET, ++ "failed to call SHOW SPHINX STATUS: --skip-sphinx was specified", ++ MYF(0) ); ++ SPH_RET(TRUE); ++ } ++ CSphSEThreadData * pTls = (CSphSEThreadData*) thd->ha_data[sphinx_hton.slot]; ++#endif ++ ++ if ( pTls && pTls->m_bStats ) ++ { ++ const CSphSEStats * pStats = &pTls->m_tStats; ++ buf1len = my_snprintf ( buf1, sizeof(buf1), ++ "total: %d, total found: %d, time: %d, words: %d", ++ pStats->m_iMatchesTotal, pStats->m_iMatchesFound, pStats->m_iQueryMsec, pStats->m_iWords ); ++ ++#if MYSQL_VERSION_ID>50100 ++ stat_print ( thd, sphinx_hton_name, strlen(sphinx_hton_name), ++ STRING_WITH_LEN("stats"), buf1, buf1len ); ++#else ++ field_list.push_back ( new Item_empty_string ( "Type",10 ) ); ++ field_list.push_back ( new Item_empty_string ( "Name",FN_REFLEN ) ); ++ field_list.push_back ( new Item_empty_string ( "Status",10 ) ); ++ if ( protocol->send_fields ( &field_list, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF ) ) ++ SPH_RET(TRUE); ++ ++ protocol->prepare_for_resend (); ++ protocol->store ( STRING_WITH_LEN("SPHINX"), system_charset_info ); ++ protocol->store ( STRING_WITH_LEN("stats"), system_charset_info ); ++ protocol->store ( buf1, buf1len, system_charset_info ); ++ if ( protocol->write() ) ++ SPH_RET(TRUE); ++#endif ++ ++ if ( pStats->m_iWords ) ++ { ++ for ( int i=0; im_iWords; i++ ) ++ { ++ CSphSEWordStats & tWord = pStats->m_dWords[i]; ++ buf2len = my_snprintf ( buf2, sizeof(buf2), "%s%s:%d:%d ", ++ buf2, tWord.m_sWord, tWord.m_iDocs, tWord.m_iHits ); ++ } ++ ++ // convert it if we can ++ const char * sWord = buf2; ++ int iWord = buf2len; ++ ++ String sBuf3; ++ if ( pTls->m_pQueryCharset ) ++ { ++ uint iErrors; ++ sBuf3.copy ( buf2, buf2len, pTls->m_pQueryCharset, system_charset_info, &iErrors ); ++ sWord = sBuf3.c_ptr(); ++ iWord = sBuf3.length(); ++ } ++ ++#if MYSQL_VERSION_ID>50100 ++ stat_print ( thd, sphinx_hton_name, strlen(sphinx_hton_name), ++ STRING_WITH_LEN("words"), sWord, iWord ); ++#else ++ protocol->prepare_for_resend (); ++ protocol->store ( STRING_WITH_LEN("SPHINX"), system_charset_info ); ++ protocol->store ( STRING_WITH_LEN("words"), system_charset_info ); ++ protocol->store ( sWord, iWord, system_charset_info ); ++ if ( protocol->write() ) ++ SPH_RET(TRUE); ++#endif ++ } ++ ++ // send last error or warning ++ if ( pStats->m_sLastMessage && pStats->m_sLastMessage[0] ) ++ { ++ const char * sMessageType = pStats->m_bLastError ? "error" : "warning"; ++ ++#if MYSQL_VERSION_ID>50100 ++ stat_print ( thd, sphinx_hton_name, strlen(sphinx_hton_name), ++ sMessageType, strlen(sMessageType), pStats->m_sLastMessage, strlen(pStats->m_sLastMessage) ); ++#else ++ protocol->prepare_for_resend (); ++ protocol->store ( STRING_WITH_LEN("SPHINX"), system_charset_info ); ++ protocol->store ( sMessageType, strlen(sMessageType), system_charset_info ); ++ protocol->store ( pStats->m_sLastMessage, strlen(pStats->m_sLastMessage), system_charset_info ); ++ if ( protocol->write() ) ++ SPH_RET(TRUE); ++#endif ++ } ++ ++ } else ++ { ++ #if MYSQL_VERSION_ID < 50100 ++ field_list.push_back ( new Item_empty_string ( "Type", 10 ) ); ++ field_list.push_back ( new Item_empty_string ( "Name", FN_REFLEN ) ); ++ field_list.push_back ( new Item_empty_string ( "Status", 10 ) ); ++ if ( protocol->send_fields ( &field_list, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF ) ) ++ SPH_RET(TRUE); ++ ++ protocol->prepare_for_resend (); ++ protocol->store ( STRING_WITH_LEN("SPHINX"), system_charset_info ); ++ protocol->store ( STRING_WITH_LEN("stats"), system_charset_info ); ++ protocol->store ( STRING_WITH_LEN("no query has been executed yet"), system_charset_info ); ++ if ( protocol->write() ) ++ SPH_RET(TRUE); ++ #endif ++ } ++ ++ #if MYSQL_VERSION_ID < 50100 ++ send_eof(thd); ++ #endif ++ ++ SPH_RET(FALSE); ++} ++ ++////////////////////////////////////////////////////////////////////////////// ++// HELPERS ++////////////////////////////////////////////////////////////////////////////// ++ ++static char * sphDup ( const char * sSrc, int iLen=-1 ) ++{ ++ if ( !sSrc ) ++ return NULL; ++ ++ if ( iLen<0 ) ++ iLen = strlen(sSrc); ++ ++ char * sRes = new char [ 1+iLen ]; ++ memcpy ( sRes, sSrc, iLen ); ++ sRes[iLen] = '\0'; ++ return sRes; ++} ++ ++ ++static void sphLogError ( const char * sFmt, ... ) ++{ ++ // emit timestamp ++#ifdef __WIN__ ++ SYSTEMTIME t; ++ GetLocalTime ( &t ); ++ ++ fprintf ( stderr, "%02d%02d%02d %2d:%02d:%02d SphinxSE: internal error: ", ++ (int)t.wYear % 100, (int)t.wMonth, (int)t.wDay, ++ (int)t.wHour, (int)t.wMinute, (int)t.wSecond ); ++#else ++ // Unix version ++ time_t tStamp; ++ time ( &tStamp ); ++ ++ struct tm * pParsed; ++#ifdef HAVE_LOCALTIME_R ++ struct tm tParsed; ++ localtime_r ( &tStamp, &tParsed ); ++ pParsed = &tParsed; ++#else ++ pParsed = localtime ( &tStamp ); ++#endif // HAVE_LOCALTIME_R ++ ++ fprintf ( stderr, "%02d%02d%02d %2d:%02d:%02d SphinxSE: internal error: ", ++ pParsed->tm_year % 100, pParsed->tm_mon + 1, pParsed->tm_mday, ++ pParsed->tm_hour, pParsed->tm_min, pParsed->tm_sec); ++#endif // __WIN__ ++ ++ // emit message ++ va_list ap; ++ va_start ( ap, sFmt ); ++ vfprintf ( stderr, sFmt, ap ); ++ va_end ( ap ); ++ ++ // emit newline ++ fprintf ( stderr, "\n" ); ++} ++ ++ ++ ++// the following scheme variants are recognized ++// ++// sphinx://host/index ++// sphinx://host:port/index ++static bool ParseUrl ( CSphSEShare * share, TABLE * table, bool bCreate ) ++{ ++ SPH_ENTER_FUNC(); ++ ++ if ( share ) ++ { ++ // check incoming stuff ++ if ( !table ) ++ { ++ sphLogError ( "table==NULL in ParseUrl()" ); ++ return false; ++ } ++ if ( !table->s ) ++ { ++ sphLogError ( "(table->s)==NULL in ParseUrl()" ); ++ return false; ++ } ++ ++ // free old stuff ++ share->ResetTable (); ++ ++ // fill new stuff ++ share->m_iTableFields = table->s->fields; ++ if ( share->m_iTableFields ) ++ { ++ share->m_sTableField = new char * [ share->m_iTableFields ]; ++ share->m_eTableFieldType = new enum_field_types [ share->m_iTableFields ]; ++ ++ for ( int i=0; im_iTableFields; i++ ) ++ { ++ share->m_sTableField[i] = sphDup ( table->field[i]->field_name ); ++ share->m_eTableFieldType[i] = table->field[i]->type(); ++ } ++ } ++ } ++ ++ char * sScheme = NULL; ++ char * sHost = SPHINXSE_DEFAULT_HOST; ++ char * sIndex = SPHINXSE_DEFAULT_INDEX; ++ int iPort = SPHINXSE_DEFAULT_PORT; ++ ++ bool bOk = true; ++ while ( table->s->connect_string.length!=0 ) ++ { ++ bOk = false; ++ sScheme = sphDup ( table->s->connect_string.str, table->s->connect_string.length ); ++ ++ sHost = strstr ( sScheme, "://" ); ++ if ( !sHost ) ++ break; ++ sHost[0] = '\0'; ++ sHost += 3; ++ ++ if ( strcmp ( sScheme, "sphinx" )!=0 ) ++ break; ++ ++ char * sPort = strchr ( sHost, ':' ); ++ if ( sPort ) ++ { ++ *sPort++ = '\0'; ++ if ( *sPort ) ++ { ++ sIndex = strchr ( sPort, '/' ); ++ if ( sIndex ) ++ *sIndex++ = '\0'; ++ else ++ sIndex = SPHINXSE_DEFAULT_INDEX; ++ ++ iPort = atoi(sPort); ++ if ( !iPort ) ++ iPort = SPHINXSE_DEFAULT_PORT; ++ } ++ } else ++ { ++ sIndex = strchr ( sHost, '/' ); ++ if ( sIndex ) ++ *sIndex++ = '\0'; ++ else ++ sIndex = SPHINXSE_DEFAULT_INDEX; ++ } ++ ++ bOk = true; ++ break; ++ } ++ ++ if ( !bOk ) ++ { ++ my_error ( bCreate ? ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE : ER_FOREIGN_DATA_STRING_INVALID, ++ MYF(0), table->s->connect_string ); ++ } else ++ { ++ if ( share ) ++ { ++ SafeDeleteArray ( share->m_sScheme ); ++ share->m_sScheme = sScheme; ++ share->m_sHost = sHost; ++ share->m_sIndex = sIndex; ++ share->m_iPort = (ushort)iPort; ++ } ++ } ++ if ( !bOk && !share ) ++ SafeDeleteArray ( sScheme ); ++ ++ SPH_RET(bOk); ++} ++ ++ ++// Example of simple lock controls. The "share" it creates is structure we will ++// pass to each sphinx handler. Do you have to have one of these? Well, you have ++// pieces that are used for locking, and they are needed to function. ++static CSphSEShare * get_share ( const char * table_name, TABLE * table ) ++{ ++ SPH_ENTER_FUNC(); ++ pthread_mutex_lock ( &sphinx_mutex ); ++ ++ CSphSEShare * pShare = NULL; ++ for ( ;; ) ++ { ++ // check if we already have this share ++#if MYSQL_VERSION_ID>=50120 ++ pShare = (CSphSEShare*) hash_search ( &sphinx_open_tables, (const uchar *) table_name, strlen(table_name) ); ++#else ++#ifdef __WIN__ ++ pShare = (CSphSEShare*) hash_search ( &sphinx_open_tables, (const byte *) table_name, strlen(table_name) ); ++#else ++ pShare = (CSphSEShare*) hash_search ( &sphinx_open_tables, table_name, strlen(table_name) ); ++#endif // win ++#endif // pre-5.1.20 ++ ++ if ( pShare ) ++ { ++ pShare->m_iUseCount++; ++ break; ++ } ++ ++ // try to allocate new share ++ pShare = new CSphSEShare (); ++ if ( !pShare ) ++ break; ++ ++ // try to setup it ++ pShare->m_pTableQueryCharset = table->field[2]->charset(); ++ if ( !ParseUrl ( pShare, table, false ) ) ++ { ++ SafeDelete ( pShare ); ++ break; ++ } ++ ++ // try to hash it ++ pShare->m_iTableNameLen = strlen(table_name); ++ pShare->m_sTable = sphDup ( table_name ); ++ if ( my_hash_insert ( &sphinx_open_tables, (const byte *)pShare ) ) ++ { ++ SafeDelete ( pShare ); ++ break; ++ } ++ ++ // all seems fine ++ break; ++ } ++ ++ pthread_mutex_unlock ( &sphinx_mutex ); ++ SPH_RET(pShare); ++} ++ ++ ++// Free lock controls. We call this whenever we close a table. If the table had ++// the last reference to the share then we free memory associated with it. ++static int free_share ( CSphSEShare * pShare ) ++{ ++ SPH_ENTER_FUNC(); ++ pthread_mutex_lock ( &sphinx_mutex ); ++ ++ if ( !--pShare->m_iUseCount ) ++ { ++ hash_delete ( &sphinx_open_tables, (byte *)pShare ); ++ SafeDelete ( pShare ); ++ } ++ ++ pthread_mutex_unlock ( &sphinx_mutex ); ++ SPH_RET(0); ++} ++ ++ ++#if MYSQL_VERSION_ID>50100 ++static handler * sphinx_create_handler ( handlerton * hton, TABLE_SHARE * table, MEM_ROOT * mem_root ) ++{ ++ return new ( mem_root ) ha_sphinx ( hton, table ); ++} ++#endif ++ ++////////////////////////////////////////////////////////////////////////////// ++// CLIENT-SIDE REQUEST STUFF ++////////////////////////////////////////////////////////////////////////////// ++ ++CSphSEQuery::CSphSEQuery ( const char * sQuery, int iLength, const char * sIndex ) ++ : m_sHost ( "" ) ++ , m_iPort ( 0 ) ++ , m_sIndex ( sIndex ? sIndex : "*" ) ++ , m_iOffset ( 0 ) ++ , m_iLimit ( 20 ) ++ , m_bQuery ( false ) ++ , m_sQuery ( "" ) ++ , m_pWeights ( NULL ) ++ , m_iWeights ( 0 ) ++ , m_eMode ( SPH_MATCH_ALL ) ++ , m_eRanker ( SPH_RANK_PROXIMITY_BM25 ) ++ , m_eSort ( SPH_SORT_RELEVANCE ) ++ , m_sSortBy ( "" ) ++ , m_iMaxMatches ( 1000 ) ++ , m_iMaxQueryTime ( 0 ) ++ , m_iMinID ( 0 ) ++ , m_iMaxID ( 0 ) ++ , m_iFilters ( 0 ) ++ , m_eGroupFunc ( SPH_GROUPBY_DAY ) ++ , m_sGroupBy ( "" ) ++ , m_sGroupSortBy ( "@group desc" ) ++ , m_iCutoff ( 0 ) ++ , m_iRetryCount ( 0 ) ++ , m_iRetryDelay ( 0 ) ++ , m_sGroupDistinct ( "" ) ++ , m_iIndexWeights ( 0 ) ++ , m_iFieldWeights ( 0 ) ++ , m_bGeoAnchor ( false ) ++ , m_sGeoLatAttr ( "" ) ++ , m_sGeoLongAttr ( "" ) ++ , m_fGeoLatitude ( 0.0f ) ++ , m_fGeoLongitude ( 0.0f ) ++ , m_sComment ( "" ) ++ ++ , m_pBuf ( NULL ) ++ , m_pCur ( NULL ) ++ , m_iBufLeft ( 0 ) ++ , m_bBufOverrun ( false ) ++{ ++ m_sQueryBuffer = new char [ iLength+2 ]; ++ memcpy ( m_sQueryBuffer, sQuery, iLength ); ++ m_sQueryBuffer[iLength]= ';'; ++ m_sQueryBuffer[iLength+1]= '\0'; ++} ++ ++ ++CSphSEQuery::~CSphSEQuery () ++{ ++ SPH_ENTER_METHOD(); ++ SafeDeleteArray ( m_sQueryBuffer ); ++ SafeDeleteArray ( m_pWeights ); ++ SafeDeleteArray ( m_pBuf ); ++ SPH_VOID_RET(); ++} ++ ++ ++int CSphSEQuery::ParseArray ( uint32 ** ppValues, const char * sValue ) ++{ ++ SPH_ENTER_METHOD(); ++ ++// assert ( ppValues ); ++// assert ( !(*ppValues) ); ++ ++ const char * p; ++ bool bPrevDigit = false; ++ int iValues = 0; ++ ++ // count the values ++ for ( p=sValue; *p; p++ ) ++ { ++ bool bDigit = ( (*p)>='0' && (*p)<='9' ); ++ if ( bDigit && !bPrevDigit ) ++ iValues++; ++ bPrevDigit = bDigit; ++ } ++ if ( !iValues ) ++ SPH_RET(0); ++ ++ // extract the values ++ uint32 * pValues = new uint32 [ iValues ]; ++ *ppValues = pValues; ++ ++ int iIndex = 0; ++ uint32 uValue = 0; ++ ++ bPrevDigit = false; ++ for ( p=sValue; ; p++ ) ++ { ++ bool bDigit = ( (*p)>='0' && (*p)<='9' ); ++ ++ if ( bDigit ) ++ { ++ if ( !bPrevDigit ) ++ uValue = 0; ++ uValue = uValue*10 + ( (*p)-'0' ); ++ } ++ ++ if ( !bDigit && bPrevDigit ) ++ { ++ assert ( iIndexs && isspace(p[-1]) ) ++ p--; ++ *p = '\0'; ++ ++ return s; ++} ++ ++ ++static bool myisattr ( char c ) ++{ ++ return ++ ( c>='0' && c<='9' ) || ++ ( c>='a' && c<='z' ) || ++ ( c>='A' && c<='Z' ) || ++ c=='_'; ++} ++ ++ ++bool CSphSEQuery::ParseField ( char * sField ) ++{ ++ SPH_ENTER_METHOD(); ++ ++ // look for option name/value separator ++ char * sValue = strchr ( sField, '=' ); ++ if ( !sValue || sValue==sField || sValue[-1]=='\\' ) ++ { ++ // by default let's assume it's just query ++ if ( sField[0] ) ++ { ++ if ( m_bQuery ) ++ { ++ snprintf ( m_sParseError, sizeof(m_sParseError), "search query already specified; '%s' is redundant", sField ); ++ SPH_RET(false); ++ } else ++ { ++ m_sQuery = sField; ++ m_bQuery = true; ++ } ++ } ++ SPH_RET(true); ++ } ++ ++ // split ++ *sValue++ = '\0'; ++ sValue = chop ( sValue ); ++ int iValue = atoi ( sValue ); ++ ++ // handle options ++ char * sName = chop ( sField ); ++ ++ if ( !strcmp ( sName, "query" ) ) m_sQuery = sValue; ++ else if ( !strcmp ( sName, "host" ) ) m_sHost = sValue; ++ else if ( !strcmp ( sName, "port" ) ) m_iPort = iValue; ++ else if ( !strcmp ( sName, "index" ) ) m_sIndex = sValue; ++ else if ( !strcmp ( sName, "offset" ) ) m_iOffset = iValue; ++ else if ( !strcmp ( sName, "limit" ) ) m_iLimit = iValue; ++ else if ( !strcmp ( sName, "weights" ) ) m_iWeights = ParseArray ( &m_pWeights, sValue ); ++ else if ( !strcmp ( sName, "minid" ) ) m_iMinID = iValue; ++ else if ( !strcmp ( sName, "maxid" ) ) m_iMaxID = iValue; ++ else if ( !strcmp ( sName, "maxmatches" ) ) m_iMaxMatches = iValue; ++ else if ( !strcmp ( sName, "maxquerytime" ) ) m_iMaxQueryTime = iValue; ++ else if ( !strcmp ( sName, "groupsort" ) ) m_sGroupSortBy = sValue; ++ else if ( !strcmp ( sName, "distinct" ) ) m_sGroupDistinct = sValue; ++ else if ( !strcmp ( sName, "cutoff" ) ) m_iCutoff = iValue; ++ else if ( !strcmp ( sName, "comment" ) ) m_sComment = sValue; ++ ++ else if ( !strcmp ( sName, "mode" ) ) ++ { ++ ++ m_eMode = SPH_MATCH_ALL; ++ if ( !strcmp ( sValue, "any") ) m_eMode = SPH_MATCH_ANY; ++ else if ( !strcmp ( sValue, "phrase" ) ) m_eMode = SPH_MATCH_PHRASE; ++ else if ( !strcmp ( sValue, "boolean") ) m_eMode = SPH_MATCH_BOOLEAN; ++ else if ( !strcmp ( sValue, "ext") ) m_eMode = SPH_MATCH_EXTENDED; ++ else if ( !strcmp ( sValue, "extended") ) m_eMode = SPH_MATCH_EXTENDED; ++ else if ( !strcmp ( sValue, "ext2") ) m_eMode = SPH_MATCH_EXTENDED2; ++ else if ( !strcmp ( sValue, "extended2") ) m_eMode = SPH_MATCH_EXTENDED2; ++ else if ( !strcmp ( sValue, "all") ) m_eMode = SPH_MATCH_ALL; ++ else ++ { ++ snprintf ( m_sParseError, sizeof(m_sParseError), "unknown matching mode '%s'", sValue ); ++ SPH_RET(false); ++ } ++ } else if ( !strcmp ( sName, "ranker" ) ) ++ { ++ ++ m_eRanker = SPH_RANK_PROXIMITY_BM25; ++ if ( !strcmp ( sValue, "proximity_bm25") ) m_eRanker = SPH_RANK_PROXIMITY_BM25; ++ else if ( !strcmp ( sValue, "bm25" ) ) m_eRanker = SPH_RANK_BM25; ++ else if ( !strcmp ( sValue, "none" ) ) m_eRanker = SPH_RANK_NONE; ++ else if ( !strcmp ( sValue, "wordcount" ) ) m_eRanker = SPH_RANK_WORDCOUNT; ++ else ++ { ++ snprintf ( m_sParseError, sizeof(m_sParseError), "unknown ranking mode '%s'", sValue ); ++ SPH_RET(false); ++ } ++ } else if ( !strcmp ( sName, "sort" ) ) ++ { ++ static const struct ++ { ++ const char * m_sName; ++ ESphSortOrder m_eSort; ++ } dSortModes[] = ++ { ++ { "relevance", SPH_SORT_RELEVANCE }, ++ { "attr_desc:", SPH_SORT_ATTR_DESC }, ++ { "attr_asc:", SPH_SORT_ATTR_ASC }, ++ { "time_segments:", SPH_SORT_TIME_SEGMENTS }, ++ { "extended:", SPH_SORT_EXTENDED }, ++ { "expr:", SPH_SORT_EXPR } ++ }; ++ ++ int i; ++ const int nModes = sizeof(dSortModes)/sizeof(dSortModes[0]); ++ for ( i=0; im_sQueryBuffer && pNext[-1]=='\\' && pNext[1]!='\0' ) ++ { ++ pNext++; ++ continue; ++ } ++ ++ // handle semicolon-separated clauses ++ *pNext++ = '\0'; ++ if ( !ParseField ( pCur ) ) ++ SPH_RET(false); ++ pCur = pNext; ++ } ++ ++ SPH_RET(true); ++} ++ ++ ++void CSphSEQuery::SendBytes ( const void * pBytes, int iBytes ) ++{ ++ SPH_ENTER_METHOD(); ++ if ( m_iBufLeftvariables.engine_condition_pushdown = true; ++ SPH_VOID_RET(); ++} ++ ++ ++// If frm_error() is called then we will use this to to find out what file extentions ++// exist for the storage engine. This is also used by the default rename_table and ++// delete_table method in handler.cc. ++const char ** ha_sphinx::bas_ext() const ++{ ++ return ha_sphinx_exts; ++} ++ ++ ++// Used for opening tables. The name will be the name of the file. ++// A table is opened when it needs to be opened. For instance ++// when a request comes in for a select on the table (tables are not ++// open and closed for each request, they are cached). ++// ++// Called from handler.cc by handler::ha_open(). The server opens all tables by ++// calling ha_open() which then calls the handler specific open(). ++int ha_sphinx::open ( const char * name, int, uint ) ++{ ++ SPH_ENTER_METHOD(); ++ m_pShare = get_share ( name, table ); ++ if ( !m_pShare ) ++ SPH_RET(1); ++ ++ thr_lock_data_init ( &m_pShare->m_tLock, &m_tLock, NULL ); ++ ++ #if MYSQL_VERSION_ID>50100 ++ *thd_ha_data ( table->in_use, ht ) = NULL; ++ #else ++ table->in_use->ha_data [ sphinx_hton.slot ] = NULL; ++ #endif ++ ++ SPH_RET(0); ++} ++ ++ ++int ha_sphinx::ConnectToSearchd ( const char * sQueryHost, int iQueryPort ) ++{ ++ SPH_ENTER_METHOD(); ++ ++ struct sockaddr_in sa; ++ in_addr_t ip_addr; ++ int version; ++ uint uClientVersion = htonl ( SPHINX_SEARCHD_PROTO ); ++ ++ const char * sHost = ( sQueryHost && *sQueryHost ) ? sQueryHost : m_pShare->m_sHost; ++ ushort iPort = iQueryPort ? (ushort)iQueryPort : m_pShare->m_iPort; ++ ++ memset ( &sa, 0, sizeof(sa) ); ++ sa.sin_family = AF_INET; ++ ++ // prepare host address ++ if ( (int)( ip_addr=inet_addr(sHost) ) != (int)INADDR_NONE ) ++ { ++ memcpy ( &sa.sin_addr, &ip_addr, sizeof(ip_addr) ); ++ } else ++ { ++ int tmp_errno; ++ struct hostent tmp_hostent, *hp; ++ char buff2 [ GETHOSTBYNAME_BUFF_SIZE ]; ++ ++ hp = my_gethostbyname_r ( sHost, &tmp_hostent, ++ buff2, sizeof(buff2), &tmp_errno ); ++ if ( !hp ) ++ { ++ my_gethostbyname_r_free(); ++ ++ char sError[256]; ++ my_snprintf ( sError, sizeof(sError), "failed to resolve searchd host (name=%s)", sHost ); ++ ++ my_error ( ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0), sError ); ++ SPH_RET(-1); ++ } ++ ++ memcpy ( &sa.sin_addr, hp->h_addr, ++ Min ( sizeof(sa.sin_addr), (size_t)hp->h_length ) ); ++ my_gethostbyname_r_free(); ++ } ++ ++ sa.sin_port = htons(iPort); ++ ++ char sError[256]; ++ int iSocket = socket ( AF_INET, SOCK_STREAM, 0 ); ++ ++ if ( iSocket<0 ) ++ { ++ my_error ( ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0), "failed to create client socket" ); ++ SPH_RET(-1); ++ } ++ ++ if ( connect ( iSocket, (struct sockaddr *) &sa, sizeof(sa) )<0 ) ++ { ++ my_snprintf ( sError, sizeof(sError), "failed to connect to searchd (host=%s, port=%d)", ++ sHost, iPort ); ++ my_error ( ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0), sError ); ++ SPH_RET(-1); ++ } ++ ++ if ( ::recv ( iSocket, (char *)&version, sizeof(version), 0 )!=sizeof(version) ) ++ { ++ ::closesocket ( iSocket ); ++ my_snprintf ( sError, sizeof(sError), "failed to receive searchd version (host=%s, port=%d)", ++ sHost, iPort ); ++ my_error ( ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0), sError ); ++ SPH_RET(-1); ++ } ++ ++ if ( ::send ( iSocket, (char*)&uClientVersion, sizeof(uClientVersion), 0 )!=sizeof(uClientVersion) ) ++ { ++ ::closesocket ( iSocket ); ++ my_snprintf ( sError, sizeof(sError), "failed to send client version (host=%s, port=%d)", ++ sHost, iPort ); ++ my_error ( ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0), sError ); ++ SPH_RET(-1); ++ } ++ ++ SPH_RET(iSocket); ++} ++ ++ ++// Closes a table. We call the free_share() function to free any resources ++// that we have allocated in the "shared" structure. ++// ++// Called from sql_base.cc, sql_select.cc, and table.cc. ++// In sql_select.cc it is only used to close up temporary tables or during ++// the process where a temporary table is converted over to being a ++// myisam table. ++// For sql_base.cc look at close_data_tables(). ++int ha_sphinx::close() ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( free_share(m_pShare) ); ++} ++ ++ ++int ha_sphinx::write_row ( uchar * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_WRONG_COMMAND ); ++} ++ ++ ++int ha_sphinx::update_row ( const uchar *, uchar * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_WRONG_COMMAND ); ++} ++ ++ ++int ha_sphinx::delete_row ( const uchar * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_WRONG_COMMAND ); ++} ++ ++ ++// keynr is key (index) number ++// sorted is 1 if result MUST be sorted according to index ++int ha_sphinx::index_init ( uint keynr, bool ) ++{ ++ SPH_ENTER_METHOD(); ++ active_index = keynr; ++ SPH_RET(0); ++} ++ ++ ++int ha_sphinx::index_end() ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET(0); ++} ++ ++ ++uint32 ha_sphinx::UnpackDword () ++{ ++ if ( m_pCur+sizeof(uint32)>m_pResponseEnd ) ++ { ++ m_pCur = m_pResponseEnd; ++ m_bUnpackError = true; ++ return 0; ++ } ++ ++ uint32 uRes = ntohl ( sphUnalignedRead ( *(uint32*)m_pCur ) ); ++ m_pCur += sizeof(uint32); ++ return uRes; ++} ++ ++ ++char * ha_sphinx::UnpackString () ++{ ++ uint32 iLen = UnpackDword (); ++ if ( !iLen ) ++ return NULL; ++ ++ if ( m_pCur+iLen>m_pResponseEnd ) ++ { ++ m_pCur = m_pResponseEnd; ++ m_bUnpackError = true; ++ return NULL; ++ } ++ ++ char * sRes = new char [ 1+iLen ]; ++ memcpy ( sRes, m_pCur, iLen ); ++ sRes[iLen] = '\0'; ++ m_pCur += iLen; ++ return sRes; ++} ++ ++ ++static inline const char * FixNull ( const char * s ) ++{ ++ return s ? s : "(null)"; ++} ++ ++ ++bool ha_sphinx::UnpackSchema () ++{ ++ SPH_ENTER_METHOD(); ++ ++ // cleanup ++ if ( m_dFields ) ++ for ( int i=0; i<(int)m_iFields; i++ ) ++ SafeDeleteArray ( m_dFields[i] ); ++ SafeDeleteArray ( m_dFields ); ++ ++ // unpack network packet ++ uint32 uStatus = UnpackDword (); ++ char * sMessage = NULL; ++ ++ if ( uStatus!=SEARCHD_OK ) ++ { ++ sMessage = UnpackString (); ++ CSphSEThreadData * pTls = GetTls (); ++ if ( pTls ) ++ { ++ strncpy ( pTls->m_tStats.m_sLastMessage, sMessage, sizeof(pTls->m_tStats.m_sLastMessage) ); ++ pTls->m_tStats.m_bLastError = ( uStatus==SEARCHD_ERROR ); ++ } ++ ++ if ( uStatus==SEARCHD_ERROR ) ++ { ++ char sError[1024]; ++ my_snprintf ( sError, sizeof(sError), "searchd error: %s", sMessage ); ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), sError ); ++ SafeDeleteArray ( sMessage ); ++ SPH_RET ( false ); ++ } ++ } ++ ++ m_iFields = UnpackDword (); ++ m_dFields = new char * [ m_iFields ]; ++ if ( !m_dFields ) ++ { ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), "INTERNAL ERROR: UnpackSchema() failed (fields alloc error)" ); ++ SPH_RET(false); ++ } ++ ++ for ( uint32 i=0; im_iTableFields; j++ ) ++ { ++ const char * sTableField = m_pShare->m_sTableField[j]; ++ const char * sAttrField = m_dAttrs[i].m_sName; ++ if ( m_dAttrs[i].m_sName[0]=='@' ) ++ { ++ const char * sAtPrefix = "_sph_"; ++ if ( strncmp ( sTableField, sAtPrefix, strlen(sAtPrefix) ) ) ++ continue; ++ sTableField += strlen(sAtPrefix); ++ sAttrField++; ++ } ++ ++ if ( !strcasecmp ( sAttrField, sTableField ) ) ++ { ++ // we're almost good, but ++ // let's enforce that timestamp columns can only receive timestamp attributes ++ if ( m_pShare->m_eTableFieldType[j]!=MYSQL_TYPE_TIMESTAMP || m_dAttrs[i].m_uType==SPH_ATTR_TIMESTAMP ) ++ m_dAttrs[i].m_iField = j; ++ break; ++ } ++ } ++ } ++ ++ m_iMatchesTotal = UnpackDword (); ++ m_bId64 = UnpackDword (); ++ ++ // network packet unpacked; build unbound fields map ++ SafeDeleteArray ( m_dUnboundFields ); ++ m_dUnboundFields = new int [ m_pShare->m_iTableFields ]; ++ ++ for ( int i=0; im_iTableFields; i++ ) ++ { ++ if ( im_eTableFieldType[i]==MYSQL_TYPE_TIMESTAMP ) ++ m_dUnboundFields[i] = SPH_ATTR_TIMESTAMP; ++ ++ else ++ m_dUnboundFields[i] = SPH_ATTR_INTEGER; ++ } ++ ++ for ( uint32 i=0; i=0 ) ++ m_dUnboundFields [ m_dAttrs[i].m_iField ] = SPH_ATTR_NONE; ++ ++ if ( m_bUnpackError ) ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), "INTERNAL ERROR: UnpackSchema() failed (unpack error)" ); ++ ++ SPH_RET(!m_bUnpackError); ++} ++ ++ ++bool ha_sphinx::UnpackStats ( CSphSEStats * pStats ) ++{ ++ assert ( pStats ); ++ ++ char * pCurSave = m_pCur; ++ for ( uint i=0; im_iMatchesTotal = UnpackDword (); ++ pStats->m_iMatchesFound = UnpackDword (); ++ pStats->m_iQueryMsec = UnpackDword (); ++ pStats->m_iWords = UnpackDword (); ++ ++ if ( m_bUnpackError ) ++ return false; ++ ++ SafeDeleteArray ( pStats->m_dWords ); ++ if ( pStats->m_iWords<0 || pStats->m_iWords>=SPHINXSE_MAX_KEYWORDSTATS ) ++ return false; ++ pStats->m_dWords = new CSphSEWordStats [ pStats->m_iWords ]; ++ if ( !pStats->m_dWords ) ++ return false; ++ ++ for ( int i=0; im_iWords; i++ ) ++ { ++ CSphSEWordStats & tWord = pStats->m_dWords[i]; ++ tWord.m_sWord = UnpackString (); ++ tWord.m_iDocs = UnpackDword (); ++ tWord.m_iHits = UnpackDword (); ++ } ++ ++ if ( m_bUnpackError ) ++ return false; ++ ++ m_pCur = pCurSave; ++ return true; ++} ++ ++ ++/// condition pushdown implementation, to properly intercept WHERE clauses on my columns ++const COND * ha_sphinx::cond_push ( const COND * cond ) ++{ ++ // catch the simplest case: query_column="some text" ++ for ( ;; ) ++ { ++ if ( cond->type()!=COND::FUNC_ITEM ) ++ break; ++ ++ Item_func * condf = (Item_func *)cond; ++ if ( condf->functype()!=Item_func::EQ_FUNC || condf->argument_count()!=2 ) ++ break; ++ ++ Item ** args = condf->arguments(); ++ if ( args[0]->type()!=COND::FIELD_ITEM || args[1]->type()!=COND::STRING_ITEM ) ++ break; ++ ++ Item_field * pField = (Item_field *) args[0]; ++ if ( pField->field->field_index!=2 ) // FIXME! magic key index ++ break; ++ ++ // get my tls ++ CSphSEThreadData * pTls = GetTls (); ++ if ( !pTls ) ++ break; ++ ++ // copy the query, and let know that we intercepted this condition ++ Item_string * pString = (Item_string *) args[1]; ++ pTls->m_bQuery = true; ++ strncpy ( pTls->m_sQuery, pString->str_value.c_ptr(), sizeof(pTls->m_sQuery) ); ++ pTls->m_sQuery[sizeof(pTls->m_sQuery)-1] = '\0'; ++ pTls->m_pQueryCharset = pString->str_value.charset(); ++ return NULL; ++ } ++ ++ // don't change anything ++ return cond; ++} ++ ++ ++/// condition popup ++void ha_sphinx::cond_pop () ++{ ++ CSphSEThreadData * pTls = GetTls (); ++ if ( pTls && pTls->m_bQuery ) ++ pTls->m_bQuery = false; ++ return; ++} ++ ++ ++/// get TLS (maybe allocate it, too) ++CSphSEThreadData * ha_sphinx::GetTls() ++{ ++ // where do we store that pointer in today's version? ++ CSphSEThreadData ** ppTls; ++#if MYSQL_VERSION_ID>50100 ++ ppTls = (CSphSEThreadData**) thd_ha_data ( table->in_use, ht ); ++#else ++ ppTls = (CSphSEThreadData**) ¤t_thd->ha_data[sphinx_hton.slot]; ++#endif // >50100 ++ ++ // allocate if needed ++ if ( !*ppTls ) ++ *ppTls = new CSphSEThreadData (); ++ ++ // errors will be handled by caller ++ return *ppTls; ++} ++ ++ ++// Positions an index cursor to the index specified in the handle. Fetches the ++// row if available. If the key value is null, begin at the first key of the ++// index. ++int ha_sphinx::index_read ( byte * buf, const byte * key, uint key_len, enum ha_rkey_function ) ++{ ++ SPH_ENTER_METHOD(); ++ char sError[256]; ++ ++ // set new data for thd->ha_data, it is used in show_status ++ CSphSEThreadData * pTls = GetTls(); ++ if ( !pTls ) ++ { ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), "INTERNAL ERROR: TLS malloc() failed" ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ pTls->m_tStats.Reset (); ++ ++ // parse query ++ if ( pTls->m_bQuery ) ++ { ++ // we have a query from condition pushdown ++ m_pCurrentKey = (const byte *) pTls->m_sQuery; ++ m_iCurrentKeyLen = strlen(pTls->m_sQuery); ++ } else ++ { ++ // just use the key (might be truncated) ++ m_pCurrentKey = key+HA_KEY_BLOB_LENGTH; ++ m_iCurrentKeyLen = uint2korr(key); // or maybe key_len? ++ pTls->m_pQueryCharset = m_pShare ? m_pShare->m_pTableQueryCharset : NULL; ++ } ++ ++ CSphSEQuery q ( (const char*)m_pCurrentKey, m_iCurrentKeyLen, m_pShare->m_sIndex ); ++ if ( !q.Parse () ) ++ { ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), q.m_sParseError ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ // do connect ++ int iSocket = ConnectToSearchd ( q.m_sHost, q.m_iPort ); ++ if ( iSocket<0 ) ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ ++ // my buffer ++ char * pBuffer; // will be free by CSphSEQuery dtor; do NOT free manually ++ int iReqLen = q.BuildRequest ( &pBuffer ); ++ ++ if ( iReqLen<=0 ) ++ { ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), "INTERNAL ERROR: q.BuildRequest() failed" ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ // send request ++ ::send ( iSocket, pBuffer, iReqLen, 0 ); ++ ++ // receive reply ++ char sHeader[8]; ++ int iGot = ::recv ( iSocket, sHeader, sizeof(sHeader), RECV_FLAGS ); ++ if ( iGot!=sizeof(sHeader) ) ++ { ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), "failed to receive response header (searchd went away?)" ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ short int uRespStatus = ntohs ( sphUnalignedRead ( *(short int*)( &sHeader[0] ) ) ); ++ short int uRespVersion = ntohs ( sphUnalignedRead ( *(short int*)( &sHeader[2] ) ) ); ++ uint uRespLength = ntohl ( sphUnalignedRead ( *(uint *)( &sHeader[4] ) ) ); ++ SPH_DEBUG ( "got response header (status=%d version=%d length=%d)", ++ uRespStatus, uRespVersion, uRespLength ); ++ ++ SafeDeleteArray ( m_pResponse ); ++ if ( uRespLength<=SPHINXSE_MAX_ALLOC ) ++ m_pResponse = new char [ uRespLength+1 ]; ++ ++ if ( !m_pResponse ) ++ { ++ my_snprintf ( sError, sizeof(sError), "bad searchd response length (length=%u)", uRespLength ); ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), sError ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ int iRecvLength = 0; ++ while ( iRecvLength<(int)uRespLength ) ++ { ++ int iRecv = ::recv ( iSocket, m_pResponse+iRecvLength, uRespLength-iRecvLength, RECV_FLAGS ); ++ if ( iRecv<0 ) ++ break; ++ iRecvLength += iRecv; ++ } ++ ++ ::closesocket ( iSocket ); ++ iSocket = -1; ++ ++ if ( iRecvLength!=(int)uRespLength ) ++ { ++ my_snprintf ( sError, sizeof(sError), "net read error (expected=%d, got=%d)", uRespLength, iRecvLength ); ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), sError ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ // we'll have a message, at least ++ pTls->m_bStats = true; ++ ++ // parse reply ++ m_iCurrentPos = 0; ++ m_pCur = m_pResponse; ++ m_pResponseEnd = m_pResponse + uRespLength; ++ m_bUnpackError = false; ++ ++ if ( uRespStatus!=SEARCHD_OK ) ++ { ++ char * sMessage = UnpackString (); ++ if ( !sMessage ) ++ { ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), "no valid response from searchd (status=%d, resplen=%d)", ++ uRespStatus, uRespLength ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ strncpy ( pTls->m_tStats.m_sLastMessage, sMessage, sizeof(pTls->m_tStats.m_sLastMessage) ); ++ SafeDeleteArray ( sMessage ); ++ ++ if ( uRespStatus!=SEARCHD_WARNING ) ++ { ++ my_snprintf ( sError, sizeof(sError), "searchd error: %s", pTls->m_tStats.m_sLastMessage ); ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), sError ); ++ ++ pTls->m_tStats.m_bLastError = true; ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ } ++ ++ if ( !UnpackSchema () ) ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ ++ if ( !UnpackStats ( &pTls->m_tStats ) ) ++ { ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), "INTERNAL ERROR: UnpackStats() failed" ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ SPH_RET ( get_rec ( buf, key, key_len ) ); ++} ++ ++ ++// Positions an index cursor to the index specified in key. Fetches the ++// row if any. This is only used to read whole keys. ++int ha_sphinx::index_read_idx ( byte *, uint, const byte *, uint, enum ha_rkey_function ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_WRONG_COMMAND ); ++} ++ ++ ++// Used to read forward through the index. ++int ha_sphinx::index_next ( byte * buf ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( get_rec ( buf, m_pCurrentKey, m_iCurrentKeyLen ) ); ++} ++ ++ ++int ha_sphinx::index_next_same ( byte * buf, const byte * key, uint keylen ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( get_rec ( buf, key, keylen ) ); ++} ++ ++ ++int ha_sphinx::get_rec ( byte * buf, const byte *, uint ) ++{ ++ SPH_ENTER_METHOD(); ++ ++ if ( m_iCurrentPos>=m_iMatchesTotal ) ++ { ++ SafeDeleteArray ( m_pResponse ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ #if MYSQL_VERSION_ID>50100 ++ my_bitmap_map * org_bitmap = dbug_tmp_use_all_columns ( table, table->write_set ); ++ #endif ++ Field ** field = table->field; ++ ++ // unpack and return the match ++ longlong uMatchID = UnpackDword (); ++ if ( m_bId64 ) ++ uMatchID = ( uMatchID<<32 ) + UnpackDword(); ++ uint32 uMatchWeight = UnpackDword (); ++ ++ field[0]->store ( uMatchID, 1 ); ++ field[1]->store ( uMatchWeight, 1 ); ++ field[2]->store ( (const char*)m_pCurrentKey, m_iCurrentKeyLen, &my_charset_bin ); ++ ++ for ( uint32 i=0; i0 && !m_bUnpackError; uValue-- ) ++ UnpackDword(); ++ continue; ++ } ++ ++ Field * af = field [ m_dAttrs[i].m_iField ]; ++ switch ( m_dAttrs[i].m_uType ) ++ { ++ case SPH_ATTR_INTEGER: ++ case SPH_ATTR_ORDINAL: ++ case SPH_ATTR_BOOL: ++ af->store ( uValue, 1 ); ++ break; ++ ++ case SPH_ATTR_FLOAT: ++ af->store ( sphDW2F(uValue) ); ++ break; ++ ++ case SPH_ATTR_TIMESTAMP: ++ if ( af->type()==MYSQL_TYPE_TIMESTAMP ) ++ longstore ( af->ptr, uValue ); // because store() does not accept timestamps ++ else ++ af->store ( uValue, 1 ); ++ break; ++ ++ case ( SPH_ATTR_MULTI | SPH_ATTR_INTEGER ): ++ if ( uValue<=0 ) ++ { ++ // shortcut, empty MVA set ++ af->store ( "", 0, &my_charset_bin ); ++ ++ } else ++ { ++ // convert MVA set to comma-separated string ++ char sBuf[1024]; // FIXME! magic size ++ char * pCur = sBuf; ++ ++ for ( ; uValue>0 && !m_bUnpackError; uValue-- ) ++ { ++ uint32 uEntry = UnpackDword (); ++ if ( pCur < sBuf+sizeof(sBuf)-16 ) // 10 chars per 32bit value plus some safety bytes ++ { ++ sprintf ( pCur, "%u", uEntry ); ++ while ( *pCur ) *pCur++; ++ if ( uValue>1 ) ++ *pCur++ = ','; // non-trailing commas ++ } ++ } ++ ++ af->store ( sBuf, pCur-sBuf, &my_charset_bin ); ++ } ++ break; ++ ++ default: ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), "INTERNAL ERROR: unhandled attr type" ); ++ SafeDeleteArray ( m_pResponse ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ } ++ ++ if ( m_bUnpackError ) ++ { ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), "INTERNAL ERROR: response unpacker failed" ); ++ SafeDeleteArray ( m_pResponse ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ // zero out unmapped fields ++ for ( int i=SPHINXSE_SYSTEM_COLUMNS; i<(int)table->s->fields; i++ ) ++ if ( m_dUnboundFields[i]!=SPH_ATTR_NONE ) ++ switch ( m_dUnboundFields[i] ) ++ { ++ case SPH_ATTR_INTEGER: table->field[i]->store ( 0, 1 ); break; ++ case SPH_ATTR_TIMESTAMP: longstore ( table->field[i]->ptr, 0 ); break; ++ default: ++ my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), ++ "INTERNAL ERROR: unhandled unbound field type %d", m_dUnboundFields[i] ); ++ SafeDeleteArray ( m_pResponse ); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++ } ++ ++ memset ( buf, 0, table->s->null_bytes ); ++ m_iCurrentPos++; ++ ++ #if MYSQL_VERSION_ID > 50100 ++ dbug_tmp_restore_column_map(table->write_set, org_bitmap); ++ #endif ++ ++ SPH_RET(0); ++} ++ ++ ++// Used to read backwards through the index. ++int ha_sphinx::index_prev ( byte * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_WRONG_COMMAND ); ++} ++ ++ ++// index_first() asks for the first key in the index. ++// ++// Called from opt_range.cc, opt_sum.cc, sql_handler.cc, ++// and sql_select.cc. ++int ha_sphinx::index_first ( byte * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++} ++ ++// index_last() asks for the last key in the index. ++// ++// Called from opt_range.cc, opt_sum.cc, sql_handler.cc, ++// and sql_select.cc. ++int ha_sphinx::index_last ( byte * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_WRONG_COMMAND ); ++} ++ ++ ++int ha_sphinx::rnd_init ( bool ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET(0); ++} ++ ++ ++int ha_sphinx::rnd_end() ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET(0); ++} ++ ++ ++int ha_sphinx::rnd_next ( byte * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_END_OF_FILE ); ++} ++ ++ ++void ha_sphinx::position ( const byte * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_VOID_RET(); ++} ++ ++ ++// This is like rnd_next, but you are given a position to use ++// to determine the row. The position will be of the type that you stored in ++// ref. You can use ha_get_ptr(pos,ref_length) to retrieve whatever key ++// or position you saved when position() was called. ++// Called from filesort.cc records.cc sql_insert.cc sql_select.cc sql_update.cc. ++int ha_sphinx::rnd_pos ( byte *, byte * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_WRONG_COMMAND ); ++} ++ ++ ++#if MYSQL_VERSION_ID>=50030 ++int ha_sphinx::info ( uint ) ++#else ++void ha_sphinx::info ( uint ) ++#endif ++{ ++ SPH_ENTER_METHOD(); ++ ++ if ( table->s->keys>0 ) ++ table->key_info[0].rec_per_key[0] = 1; ++ ++ #if MYSQL_VERSION_ID>50100 ++ stats.records = 20; ++ #else ++ records = 20; ++ #endif ++ ++#if MYSQL_VERSION_ID>=50030 ++ SPH_RET(0); ++#else ++ SPH_VOID_RET(); ++#endif ++} ++ ++ ++int ha_sphinx::reset () ++{ ++ SPH_ENTER_METHOD(); ++ CSphSEThreadData * pTls = GetTls (); ++ if ( pTls ) ++ pTls->m_bQuery = false; ++ SPH_RET(0); ++} ++ ++ ++int ha_sphinx::delete_all_rows() ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET ( HA_ERR_WRONG_COMMAND ); ++} ++ ++ ++// First you should go read the section "locking functions for mysql" in ++// lock.cc to understand this. ++// This create a lock on the table. If you are implementing a storage engine ++// that can handle transacations look at ha_berkely.cc to see how you will ++// want to go about doing this. Otherwise you should consider calling flock() ++// here. ++// ++// Called from lock.cc by lock_external() and unlock_external(). Also called ++// from sql_table.cc by copy_data_between_tables(). ++int ha_sphinx::external_lock ( THD *, int ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET(0); ++} ++ ++ ++THR_LOCK_DATA ** ha_sphinx::store_lock ( THD *, THR_LOCK_DATA ** to, ++ enum thr_lock_type lock_type ) ++{ ++ SPH_ENTER_METHOD(); ++ ++ if ( lock_type!=TL_IGNORE && m_tLock.type==TL_UNLOCK ) ++ m_tLock.type=lock_type; ++ ++ *to++ = &m_tLock; ++ SPH_RET(to); ++} ++ ++ ++int ha_sphinx::delete_table ( const char * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET(0); ++} ++ ++ ++// Renames a table from one name to another from alter table call. ++// ++// If you do not implement this, the default rename_table() is called from ++// handler.cc and it will delete all files with the file extentions returned ++// by bas_ext(). ++// ++// Called from sql_table.cc by mysql_rename_table(). ++int ha_sphinx::rename_table ( const char *, const char * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET(0); ++} ++ ++ ++// Given a starting key, and an ending key estimate the number of rows that ++// will exist between the two. end_key may be empty which in case determine ++// if start_key matches any rows. ++// ++// Called from opt_range.cc by check_quick_keys(). ++ha_rows ha_sphinx::records_in_range ( uint, key_range *, key_range * ) ++{ ++ SPH_ENTER_METHOD(); ++ SPH_RET(3); // low number to force index usage ++} ++ ++ ++static inline bool IsIntegerFieldType ( enum_field_types eType ) ++{ ++ return eType==MYSQL_TYPE_LONG || eType==MYSQL_TYPE_LONGLONG; ++} ++ ++ ++// create() is called to create a database. The variable name will have the name ++// of the table. When create() is called you do not need to worry about opening ++// the table. Also, the FRM file will have already been created so adjusting ++// create_info will not do you any good. You can overwrite the frm file at this ++// point if you wish to change the table definition, but there are no methods ++// currently provided for doing that. ++// ++// Called from handle.cc by ha_create_table(). ++int ha_sphinx::create ( const char * name, TABLE * table, HA_CREATE_INFO * ) ++{ ++ SPH_ENTER_METHOD(); ++ char sError[256]; ++ ++ if ( !ParseUrl ( NULL, table, true ) ) ++ SPH_RET(-1); ++ ++ for ( ;; ) ++ { ++ // check system fields (count and types) ++ if ( table->s->fieldsfield[0]->type() ) ) ++ { ++ my_snprintf ( sError, sizeof(sError), "%s: 1st column (docid) MUST be integer or bigint", name ); ++ break; ++ } ++ ++ if ( !IsIntegerFieldType ( table->field[1]->type() ) ) ++ { ++ my_snprintf ( sError, sizeof(sError), "%s: 2nd column (weight) MUST be integer or bigint", name ); ++ break; ++ } ++ ++ enum_field_types f2 = table->field[2]->type(); ++ if ( f2!=MYSQL_TYPE_VARCHAR ++ && f2!=MYSQL_TYPE_BLOB && f2!=MYSQL_TYPE_MEDIUM_BLOB && f2!=MYSQL_TYPE_LONG_BLOB && f2!=MYSQL_TYPE_TINY_BLOB ) ++ { ++ my_snprintf ( sError, sizeof(sError), "%s: 3rd column (search query) MUST be varchar or text", name ); ++ break; ++ } ++ ++ // check attributes ++ int i; ++ for ( i=3; i<(int)table->s->fields; i++ ) ++ { ++ enum_field_types eType = table->field[i]->type(); ++ if ( eType!=MYSQL_TYPE_TIMESTAMP && !IsIntegerFieldType(eType) && eType!=MYSQL_TYPE_VARCHAR && eType!=MYSQL_TYPE_FLOAT ) ++ { ++ my_snprintf ( sError, sizeof(sError), "%s: %dth column (attribute %s) MUST be integer, bigint, timestamp, varchar, or float", ++ name, i+1, table->field[i]->field_name ); ++ break; ++ } ++ } ++ ++ if ( i!=(int)table->s->fields ) ++ break; ++ ++ // check index ++ if ( ++ table->s->keys!=1 || ++ table->key_info[0].key_parts!=1 || ++ strcasecmp ( table->key_info[0].key_part[0].field->field_name, table->field[2]->field_name ) ) ++ { ++ my_snprintf ( sError, sizeof(sError), "%s: there must be an index on '%s' column", ++ name, table->field[2]->field_name ); ++ break; ++ } ++ ++ // all good ++ sError[0] = '\0'; ++ break; ++ } ++ if ( sError[0] ) ++ { ++ my_error ( ER_CANT_CREATE_TABLE, MYF(0), sError, -1 ); ++ SPH_RET(-1); ++ } ++ ++ SPH_RET(0); ++} ++ ++ ++#if MYSQL_VERSION_ID>50100 ++struct st_mysql_storage_engine sphinx_storage_engine = ++{ ++ MYSQL_HANDLERTON_INTERFACE_VERSION ++}; ++ ++ ++mysql_declare_plugin(sphinx) ++{ ++ MYSQL_STORAGE_ENGINE_PLUGIN, ++ &sphinx_storage_engine, ++ sphinx_hton_name, ++ "Sphinx developers", ++ sphinx_hton_comment, ++ PLUGIN_LICENSE_GPL, ++ sphinx_init_func, // Plugin Init ++ sphinx_done_func, // Plugin Deinit ++ 0x0001, // 0.1 ++ NULL, NULL, NULL ++} ++mysql_declare_plugin_end; ++ ++#endif // >50100 ++ ++// ++// $Id: ha_sphinx.cc 1200 2008-03-06 20:03:07Z shodan $ ++// +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sphinx/ha_sphinx.h mysql-dfsg-5.0-5.0.51a/sql/sphinx/ha_sphinx.h +--- mysql-dfsg-5.0-5.0.51a~/sql/sphinx/ha_sphinx.h 1970-01-01 00:00:00.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sphinx/ha_sphinx.h 2009-08-04 14:50:32.000000000 +0000 +@@ -0,0 +1,158 @@ ++// ++// $Id: ha_sphinx.h 1169 2008-02-22 12:52:37Z shodan $ ++// ++ ++#ifdef USE_PRAGMA_INTERFACE ++#pragma interface // gcc class implementation ++#endif ++ ++ ++#if MYSQL_VERSION_ID>50100 ++#define TABLE_ARG st_table_share ++#else ++#define TABLE_ARG st_table ++#endif ++ ++ ++#if MYSQL_VERSION_ID>=50120 ++typedef uchar byte; ++#endif ++ ++ ++/// forward decls ++class THD; ++struct CSphReqQuery; ++struct CSphSEShare; ++struct CSphSEAttr; ++struct CSphSEStats; ++struct CSphSEThreadData; ++ ++/// Sphinx SE handler class ++class ha_sphinx : public handler ++{ ++protected: ++ THR_LOCK_DATA m_tLock; ///< MySQL lock ++ ++ CSphSEShare * m_pShare; ///< shared lock info ++ ++ uint m_iMatchesTotal; ++ uint m_iCurrentPos; ++ const byte * m_pCurrentKey; ++ uint m_iCurrentKeyLen; ++ ++ char * m_pResponse; ///< searchd response storage ++ char * m_pResponseEnd; ///< searchd response storage end (points to wilderness!) ++ char * m_pCur; ///< current position into response ++ bool m_bUnpackError; ///< any errors while unpacking response ++ ++public: ++#if MYSQL_VERSION_ID<50100 ++ ha_sphinx ( TABLE_ARG * table_arg ); ++#else ++ ha_sphinx ( handlerton * hton, TABLE_ARG * table_arg ); ++#endif ++ ~ha_sphinx () {} ++ ++ const char * table_type () const { return "SPHINX"; } ///< SE name for display purposes ++ const char * index_type ( uint ) { return "HASH"; } ///< index type name for display purposes ++ const char ** bas_ext () const; ///< my file extensions ++ ++ #if MYSQL_VERSION_ID>50100 ++ ulonglong table_flags () const { return HA_CAN_INDEX_BLOBS; } ///< bitmap of implemented flags (see handler.h for more info) ++ #else ++ ulong table_flags () const { return HA_CAN_INDEX_BLOBS; } ///< bitmap of implemented flags (see handler.h for more info) ++ #endif ++ ++ ulong index_flags ( uint, uint, bool ) const { return 0; } ///< bitmap of flags that says how SE implements indexes ++ uint max_supported_record_length () const { return HA_MAX_REC_LENGTH; } ++ uint max_supported_keys () const { return 1; } ++ uint max_supported_key_parts () const { return 1; } ++ uint max_supported_key_length () const { return MAX_KEY_LENGTH; } ++ uint max_supported_key_part_length () const { return MAX_KEY_LENGTH; } ++ ++ #if MYSQL_VERSION_ID>50100 ++ virtual double scan_time () { return (double)( stats.records+stats.deleted )/20.0 + 10; } ///< called in test_quick_select to determine if indexes should be used ++ #else ++ virtual double scan_time () { return (double)( records+deleted )/20.0 + 10; } ///< called in test_quick_select to determine if indexes should be used ++ #endif ++ ++ virtual double read_time ( ha_rows rows ) { return (double)rows/20.0 + 1; } ///< index read time estimate ++ ++public: ++ int open ( const char * name, int mode, uint test_if_locked ); ++ int close (); ++ ++ int write_row ( uchar * buf ); ++ int update_row ( const uchar * old_data, uchar * new_data ); ++ int delete_row ( const uchar * buf ); ++ ++ int index_init ( uint keynr, bool sorted ); // 5.1.x ++ int index_init ( uint keynr ) { return index_init ( keynr, false ); } // 5.0.x ++ ++ int index_end (); ++ int index_read ( byte * buf, const byte * key, uint key_len, enum ha_rkey_function find_flag ); ++ int index_read_idx ( byte * buf, uint idx, const byte * key, uint key_len, enum ha_rkey_function find_flag ); ++ int index_next ( byte * buf ); ++ int index_next_same ( byte * buf, const byte * key, uint keylen ); ++ int index_prev ( byte * buf ); ++ int index_first ( byte * buf ); ++ int index_last ( byte * buf ); ++ ++ int get_rec ( byte * buf, const byte * key, uint keylen ); ++ ++ int rnd_init ( bool scan ); ++ int rnd_end (); ++ int rnd_next ( byte * buf ); ++ int rnd_pos ( byte * buf, byte * pos ); ++ void position ( const byte * record ); ++ ++#if MYSQL_VERSION_ID>=50030 ++ int info ( uint ); ++#else ++ void info ( uint ); ++#endif ++ ++ int reset(); ++ int external_lock ( THD * thd, int lock_type ); ++ int delete_all_rows (); ++ ha_rows records_in_range ( uint inx, key_range * min_key, key_range * max_key ); ++ ++ int delete_table ( const char * from ); ++ int rename_table ( const char * from, const char * to ); ++ int create ( const char * name, TABLE * form, HA_CREATE_INFO * create_info ); ++ ++ THR_LOCK_DATA **store_lock ( THD * thd, THR_LOCK_DATA ** to, enum thr_lock_type lock_type ); ++ ++public: ++ virtual const COND * cond_push ( const COND *cond ); ++ virtual void cond_pop (); ++ ++private: ++ uint32 m_iFields; ++ char ** m_dFields; ++ ++ uint32 m_iAttrs; ++ CSphSEAttr * m_dAttrs; ++ int m_bId64; ++ ++ int * m_dUnboundFields; ++ ++private: ++ int ConnectToSearchd ( const char * sQueryHost, int iQueryPort ); ++ ++ uint32 UnpackDword (); ++ char * UnpackString (); ++ bool UnpackSchema (); ++ bool UnpackStats ( CSphSEStats * pStats ); ++ ++ CSphSEThreadData * GetTls (); ++}; ++ ++ ++#if MYSQL_VERSION_ID < 50100 ++bool sphinx_show_status ( THD * thd ); ++#endif ++ ++// ++// $Id: ha_sphinx.h 1169 2008-02-22 12:52:37Z shodan $ ++// +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sphinx/plug.in mysql-dfsg-5.0-5.0.51a/sql/sphinx/plug.in +--- mysql-dfsg-5.0-5.0.51a~/sql/sphinx/plug.in 1970-01-01 00:00:00.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sphinx/plug.in 2009-08-04 14:50:32.000000000 +0000 +@@ -0,0 +1,5 @@ ++MYSQL_STORAGE_ENGINE(sphinx,, [Sphinx Storage Engine], ++ [Sphinx Storage Engines], [max,max-no-ndb]) ++MYSQL_PLUGIN_DIRECTORY(sphinx, [storage/sphinx]) ++MYSQL_PLUGIN_STATIC(sphinx, [libsphinx.a]) ++MYSQL_PLUGIN_DYNAMIC(sphinx, [ha_sphinx.la]) +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sql_lex.h mysql-dfsg-5.0-5.0.51a/sql/sql_lex.h +--- mysql-dfsg-5.0-5.0.51a~/sql/sql_lex.h 2008-01-11 14:43:14.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sql_lex.h 2009-08-04 14:50:32.000000000 +0000 +@@ -57,6 +57,7 @@ + SQLCOM_SHOW_DATABASES, SQLCOM_SHOW_TABLES, SQLCOM_SHOW_FIELDS, + SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_LOGS, SQLCOM_SHOW_STATUS, + SQLCOM_SHOW_INNODB_STATUS, SQLCOM_SHOW_NDBCLUSTER_STATUS, SQLCOM_SHOW_MUTEX_STATUS, ++ SQLCOM_SHOW_SPHINX_STATUS, + SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT, + SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS, + SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS, +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sql_parse.cc mysql-dfsg-5.0-5.0.51a/sql/sql_parse.cc +--- mysql-dfsg-5.0-5.0.51a~/sql/sql_parse.cc 2008-01-11 14:43:38.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sql_parse.cc 2009-08-04 14:50:32.000000000 +0000 +@@ -24,6 +24,9 @@ + #ifdef HAVE_INNOBASE_DB + #include "ha_innodb.h" + #endif ++#ifdef HAVE_SPHINX_DB ++#include "sphinx/ha_sphinx.h" ++#endif + + #ifdef HAVE_NDBCLUSTER_DB + #include "ha_ndbcluster.h" +@@ -2913,6 +2916,15 @@ + break; + } + #endif ++#ifdef HAVE_SPHINX_DB ++ case SQLCOM_SHOW_SPHINX_STATUS: ++ { ++ if (check_global_access(thd, SUPER_ACL)) ++ goto error; ++ res = sphinx_show_status(thd); ++ break; ++ } ++#endif + #ifdef HAVE_REPLICATION + case SQLCOM_LOAD_MASTER_TABLE: + { +diff -urNad mysql-dfsg-5.0-5.0.51a~/sql/sql_yacc.yy mysql-dfsg-5.0-5.0.51a/sql/sql_yacc.yy +--- mysql-dfsg-5.0-5.0.51a~/sql/sql_yacc.yy 2008-01-11 14:43:29.000000000 +0000 ++++ mysql-dfsg-5.0-5.0.51a/sql/sql_yacc.yy 2009-08-04 14:50:32.000000000 +0000 +@@ -7273,6 +7273,9 @@ + case DB_TYPE_INNODB: + Lex->sql_command = SQLCOM_SHOW_INNODB_STATUS; + break; ++ case DB_TYPE_SPHINX_DB: ++ Lex->sql_command = SQLCOM_SHOW_SPHINX_STATUS; ++ break; + default: + my_error(ER_NOT_SUPPORTED_YET, MYF(0), "STATUS"); + MYSQL_YYABORT; diff -Nru /tmp/4LVtUT6EYc/mysql-dfsg-5.0-5.0.51a/debian/rules /tmp/BTg1zmEllB/mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/rules --- mysql-dfsg-5.0-5.0.51a/debian/rules 2009-08-04 17:40:20.000000000 +0000 +++ mysql-dfsg-5.0-5.0.51a-3ubuntu5/debian/rules 2009-08-04 14:52:58.000000000 +0000 @@ -51,6 +51,8 @@ if [ ! -d /proc/self ]; then echo "/proc IS NEEDED" 1>&2; exit 1; fi endif + sh -c 'PATH=$${MYSQL_BUILD_PATH:-"/bin:/usr/bin:/usr/local/bin"} \ + ./BUILD/autorun.sh' sh -c 'PATH=$${MYSQL_BUILD_PATH:-"/bin:/usr/bin"} \ CC=$${MYSQL_BUILD_CC:-gcc} \ CFLAGS=$${MYSQL_BUILD_CFLAGS:-"-DBIG_JOINS=1 -O2 -fPIC"} \ @@ -99,6 +101,7 @@ --with-csv-storage-engine \ --with-federated-storage-engine \ --with-blackhole-storage-engine \ + --with-sphinx-storage-engine \ --without-embedded-server \ --with-ndbcluster \ --with-ndb-ccflags="-fPIC" \