SQL: Pilih transaksi yang barisnya bukan kriteria di dalam tabel yang sama

Saya punya meja dengan transaksi:

Transactions
------------
id | account | type | date_time             | amount
----------------------------------------------------
 1 | 001     | 'R'  | '2012-01-01 10:01:00' | 1000
 2 | 003     | 'R'  | '2012-01-02 12:53:10' | 1500
 3 | 003     | 'A'  | '2012-01-03 13:10:01' | -1500
 4 | 002     | 'R'  | '2012-01-03 17:56:00' | 2000
 5 | 001     | 'R'  | '2012-01-04 12:30:01' | 1000
 6 | 002     | 'A'  | '2012-01-04 13:23:01' | -2000
 7 | 003     | 'R'  | '2012-01-04 15:13:10' | 3000
 8 | 003     | 'R'  | '2012-01-05 12:12:00' | 1250
 9 | 003     | 'A'  | '2012-01-06 17:24:01' | -1250

dan saya ingin memilih semua jenis tertentu ('R'), tetapi bukan yang segera (dalam urutan bidang tanggal_waktu) memiliki transaksi lain dari jenis lain ('A') untuk akun yang sama yang diajukan...

Jadi, kueri harus menampilkan baris berikut, dengan mempertimbangkan contoh sebelumnya:

id | account |type  | date                  | amount
----------------------------------------------------
 1 | 001     | 'R'  | '2012-01-01 10:01:00' | 1000
 5 | 001     | 'R'  | '2012-01-04 12:30:01' | 1000
 7 | 003     | 'R'  | '2012-01-04 15:13:10' | 3000

(Seperti yang Anda lihat, baris 2 tidak ditampilkan karena baris 3 'membatalkan'... juga baris 4 'dibatalkan' oleh baris 6'; Baris 7 muncul (walaupun akun 003 milik baris #2 yang dibatalkan , kali ini di baris 7 tidak dibatalkan oleh baris 'A' mana pun); Dan baris 8 tidak akan muncul (juga untuk akun 003 karena sekarang yang ini dibatalkan oleh 9, yang tidak membatalkan 7 juga, hanya yang sebelumnya satu: 8...

Saya telah mencoba Gabung, subkueri di klausa Where tetapi saya benar-benar tidak yakin bagaimana cara membuat kueri saya...

Apa yang saya coba:

Mencoba bergabung:

   SELECT trans.type as type,
          trans.amount as amount,
          trans.date_time as dt,
          trans.account as acct,
     FROM Transactions trans
INNER JOIN ( SELECT t.type AS type, t.acct AS acct, t.date_time AS date_time
               FROM Transactions t
              WHERE t.date_time > trans.date_time
           ORDER BY t.date_time DESC
          ) AS nextTrans
       ON nextTrans.acct = trans.acct
    WHERE trans.type IN ('R')
      AND nextTrans.type NOT IN ('A')
 ORDER BY DATE(trans.date_time) ASC

Ini menimbulkan kesalahan, karena saya tidak bisa memasukkan nilai eksternal ke GABUNG di MySQL.

Mencoba subquery di mana:

   SELECT trans.type as type,
          trans.amount as amount,
          trans.date_time as dt,
          trans.account as acct,
     FROM Transactions trans
    WHERE trans.type IN ('R')
      AND trans.datetime <
          ( SELECT t.date_time AS date_time
               FROM Transactions t
              WHERE t.account = trans.account
           ORDER BY t.date_time DESC
          ) AS nextTrans
       ON nextTrans.acct = trans.acct

 ORDER BY DATE(trans.date_time) ASC

Ini salah, saya dapat memasukkan nilai eksternal ke WHERE di MySQL tetapi saya tidak dapat menemukan cara untuk memfilter dengan benar untuk apa yang saya butuhkan...

EDIT PENTING:

Saya berhasil mencapai solusi, tetapi sekarang memerlukan optimasi yang serius. Ini dia:

SELECT *
  FROM (SELECT t1.*, tFlagged.id AS cancId, tFlagged.type AS cancFlag
          FROM transactions t1
     LEFT JOIN (SELECT t2.*
                  FROM transactions t2
              ORDER BY t2.date_time ASC ) tFlagged
            ON (t1.account=tFlagged.account
                  AND
                t1.date_time < tFlagged.date_time)
         WHERE t1.type = 'R'
      GROUP BY t1.id) tCanc
 WHERE tCanc.cancFlag IS NULL
    OR tCanc.cancFlag <> 'A'

Saya bergabung dengan tabel itu sendiri, hanya mempertimbangkan akun yang sama dan tanggal_waktu yang bagus. Gabung diurutkan berdasarkan tanggal_waktu. Pengelompokan berdasarkan id Saya hanya berhasil mendapatkan hasil join pertama, yang kebetulan merupakan transaksi berikutnya untuk akun yang sama.

Kemudian pada pilihan luar, saya memfilter yang memiliki 'A', karena itu berarti transaksi berikutnya secara efektif merupakan pembatalan. Dengan kata lain, jika tidak ada transaksi berikutnya untuk akun yang sama atau jika transaksi berikutnya adalah 'R', maka tidak dibatalkan dan harus ditampilkan di hasilnya...

Saya mengerti:

+----+---------+------+---------------------+--------+--------+----------+
| id | account | type | date_time           | amount | cancId | cancFlag |
+----+---------+------+---------------------+--------+--------+----------+
|  1 | 001     |   R  | 2012-01-01 10:01:00 |   1000 |      5 | R        |
|  5 | 001     |   R  | 2012-01-04 12:30:01 |   1000 |   NULL | NULL     |
|  7 | 003     |   R  | 2012-01-04 15:13:10 |   3000 |      8 | R        |
+----+---------+------+---------------------+--------+--------+----------+

Ini menghubungkan setiap transaksi dengan transaksi berikutnya tepat waktu untuk akun yang sama dan kemudian menyaring transaksi yang telah dibatalkan... Sukses!!

Seperti yang saya katakan, masalahnya sekarang adalah optimasi. Data asli saya memiliki banyak baris (seperti yang diharapkan dimiliki oleh tabel yang menyimpan transaksi sepanjang waktu), dan untuk tabel ~10.000 baris saat ini, saya mendapatkan hasil positif dengan kueri ini dalam 1 menit.44 detik. Saya kira itulah masalahnya dengan bergabung... (Bagi mereka yang mengetahui protokol di sini, apa yang harus saya lakukan? meluncurkan pertanyaan baru di sini dan memposting ini sebagai solusi untuk pertanyaan ini? Atau tunggu saja jawaban lainnya di sini?)


mysql sql subquery
person Javier Novoa C.    schedule 28.02.2012    source sumber
comment
Lihat: meta.stackexchange.com/questions/2950/   -  person OMG Ponies    schedule 28.02.2012
comment
terima kasih atas masukannya... :P   -  person Javier Novoa C.    schedule 28.02.2012
comment
apakah kolom id selalu diurutkan berdasarkan waktu? jika iya anda bisa bergabung di id=id+1.   -  person andrew cooke    schedule 28.02.2012
comment
tidak, maaf @andrewcooke, itu hanya penyederhanaan saja untuk contoh yang saya tunjukkan di sini... Saya berkomentar hal yang sama untuk jawaban gcbenison di sini...   -  person Javier Novoa C.    schedule 28.02.2012

Jawaban (5)


arrow_upward
2
arrow_downward

Berikut adalah solusi berdasarkan subkueri bersarang. Pertama, saya menambahkan beberapa baris untuk menangkap beberapa kasus lagi. Transaksi 10 misalnya, tidak boleh dibatalkan oleh transaksi 12, karena transaksi 11 ada di antaranya.

> select * from transactions order by date_time;
+----+---------+------+---------------------+--------+
| id | account | type | date_time           | amount |
+----+---------+------+---------------------+--------+
|  1 |       1 | R    | 2012-01-01 10:01:00 |   1000 |
|  2 |       3 | R    | 2012-01-02 12:53:10 |   1500 |
|  3 |       3 | A    | 2012-01-03 13:10:01 |  -1500 |
|  4 |       2 | R    | 2012-01-03 17:56:00 |   2000 |
|  5 |       1 | R    | 2012-01-04 12:30:01 |   1000 |
|  6 |       2 | A    | 2012-01-04 13:23:01 |  -2000 |
|  7 |       3 | R    | 2012-01-04 15:13:10 |   3000 |
|  8 |       3 | R    | 2012-01-05 12:12:00 |   1250 |
|  9 |       3 | A    | 2012-01-06 17:24:01 |  -1250 |
| 10 |       3 | R    | 2012-01-07 00:00:00 |   1250 |
| 11 |       3 | R    | 2012-01-07 05:00:00 |   4000 |
| 12 |       3 | A    | 2012-01-08 00:00:00 |  -1250 |
| 14 |       2 | R    | 2012-01-09 00:00:00 |   2000 |
| 13 |       3 | A    | 2012-01-10 00:00:00 |  -1500 |
| 15 |       2 | A    | 2012-01-11 04:00:00 |  -2000 |
| 16 |       2 | R    | 2012-01-12 00:00:00 |   5000 |
+----+---------+------+---------------------+--------+
16 rows in set (0.00 sec)

Pertama, buat kueri untuk mengambil, untuk setiap transaksi, "tanggal transaksi terbaru sebelum transaksi tersebut di akun yang sama":

SELECT t2.*,
       MAX(t1.date_time) AS prev_date
FROM transactions t1
JOIN transactions t2
ON (t1.account = t2.account
   AND t2.date_time > t1.date_time)
GROUP BY t2.account,t2.date_time
ORDER BY t2.date_time;

+----+---------+------+---------------------+--------+---------------------+
| id | account | type | date_time           | amount | prev_date           |
+----+---------+------+---------------------+--------+---------------------+
|  3 |       3 | A    | 2012-01-03 13:10:01 |  -1500 | 2012-01-02 12:53:10 |
|  5 |       1 | R    | 2012-01-04 12:30:01 |   1000 | 2012-01-01 10:01:00 |
|  6 |       2 | A    | 2012-01-04 13:23:01 |  -2000 | 2012-01-03 17:56:00 |
|  7 |       3 | R    | 2012-01-04 15:13:10 |   3000 | 2012-01-03 13:10:01 |
|  8 |       3 | R    | 2012-01-05 12:12:00 |   1250 | 2012-01-04 15:13:10 |
|  9 |       3 | A    | 2012-01-06 17:24:01 |  -1250 | 2012-01-05 12:12:00 |
| 10 |       3 | R    | 2012-01-07 00:00:00 |   1250 | 2012-01-06 17:24:01 |
| 11 |       3 | R    | 2012-01-07 05:00:00 |   4000 | 2012-01-07 00:00:00 |
| 12 |       3 | A    | 2012-01-08 00:00:00 |  -1250 | 2012-01-07 05:00:00 |
| 14 |       2 | R    | 2012-01-09 00:00:00 |   2000 | 2012-01-04 13:23:01 |
| 13 |       3 | A    | 2012-01-10 00:00:00 |  -1500 | 2012-01-08 00:00:00 |
| 15 |       2 | A    | 2012-01-11 04:00:00 |  -2000 | 2012-01-09 00:00:00 |
| 16 |       2 | R    | 2012-01-12 00:00:00 |   5000 | 2012-01-11 04:00:00 |
+----+---------+------+---------------------+--------+---------------------+
13 rows in set (0.00 sec)

Gunakan itu sebagai subkueri untuk menempatkan setiap transaksi dan pendahulunya di baris yang sama. Gunakan beberapa pemfilteran untuk menarik keluar transaksi yang kita minati - yaitu, transaksi 'A' yang pendahulunya adalah transaksi 'R' yang justru dibatalkan -

SELECT
  t3.*,transactions.*
FROM
  transactions
  JOIN
  (SELECT t2.*,
          MAX(t1.date_time) AS prev_date
   FROM transactions t1
   JOIN transactions t2
   ON (t1.account = t2.account
      AND t2.date_time > t1.date_time)
   GROUP BY t2.account,t2.date_time) t3
  ON t3.account = transactions.account
     AND t3.prev_date = transactions.date_time
     AND t3.type='A'
     AND transactions.type='R'
     AND t3.amount + transactions.amount = 0
  ORDER BY t3.date_time;


+----+---------+------+---------------------+--------+---------------------+----+---------+------+---------------------+--------+
| id | account | type | date_time           | amount | prev_date           | id | account | type | date_time           | amount |
+----+---------+------+---------------------+--------+---------------------+----+---------+------+---------------------+--------+
|  3 |       3 | A    | 2012-01-03 13:10:01 |  -1500 | 2012-01-02 12:53:10 |  2 |       3 | R    | 2012-01-02 12:53:10 |   1500 |
|  6 |       2 | A    | 2012-01-04 13:23:01 |  -2000 | 2012-01-03 17:56:00 |  4 |       2 | R    | 2012-01-03 17:56:00 |   2000 |
|  9 |       3 | A    | 2012-01-06 17:24:01 |  -1250 | 2012-01-05 12:12:00 |  8 |       3 | R    | 2012-01-05 12:12:00 |   1250 |
| 15 |       2 | A    | 2012-01-11 04:00:00 |  -2000 | 2012-01-09 00:00:00 | 14 |       2 | R    | 2012-01-09 00:00:00 |   2000 |
+----+---------+------+---------------------+--------+---------------------+----+---------+------+---------------------+--------+
4 rows in set (0.00 sec)

Dari hasil di atas terlihat bahwa kita hampir sampai - kita telah mengidentifikasi transaksi yang tidak diinginkan. Dengan menggunakan LEFT JOIN kita dapat memfilter ini dari seluruh rangkaian transaksi:

SELECT
  transactions.*
FROM
  transactions
LEFT JOIN
  (SELECT
     transactions.id
   FROM
     transactions
     JOIN
     (SELECT t2.*,
             MAX(t1.date_time) AS prev_date
      FROM transactions t1
      JOIN transactions t2
      ON (t1.account = t2.account
         AND t2.date_time > t1.date_time)
      GROUP BY t2.account,t2.date_time) t3
     ON t3.account = transactions.account
        AND t3.prev_date = transactions.date_time
        AND t3.type='A'
        AND transactions.type='R'
        AND t3.amount + transactions.amount = 0) t4
  USING(id)
  WHERE t4.id IS NULL
    AND transactions.type = 'R'
  ORDER BY transactions.date_time;

+----+---------+------+---------------------+--------+
| id | account | type | date_time           | amount |
+----+---------+------+---------------------+--------+
|  1 |       1 | R    | 2012-01-01 10:01:00 |   1000 |
|  5 |       1 | R    | 2012-01-04 12:30:01 |   1000 |
|  7 |       3 | R    | 2012-01-04 15:13:10 |   3000 |
| 10 |       3 | R    | 2012-01-07 00:00:00 |   1250 |
| 11 |       3 | R    | 2012-01-07 05:00:00 |   4000 |
| 16 |       2 | R    | 2012-01-12 00:00:00 |   5000 |
+----+---------+------+---------------------+--------+
person gcbenison    schedule 28.02.2012
comment
ya hampir sampai! tapi kenapa angka 11 jika dibatalkan 12 muncul di hasil akhir? - person Javier Novoa C.; 28.02.2012
comment
Oke, saya salah memahami pertanyaannya; Saya pikir agar A menjadi pembatalan, bidang amount-nya harus berupa negasi dari jumlah di baris R. Menghilangkan klausa AND t3.amount + transactions.amount = 0 akan menghilangkan batasan ini (dan memberikan apa yang Anda cari) - person gcbenison; 28.02.2012
comment
Tunggu! kamu lebih benar dariku! Saya tidak memperhatikan detailnya, tentu saja itulah yang saya cari :) Biarkan saya melakukan tes lebih lanjut! Saya pikir ini akhirnya yang tepat :) - person Javier Novoa C.; 29.02.2012

arrow_upward
1
arrow_downward

di sini saya sudah mencoba di MSSQL. Silakan periksa logika dan coba di mysql. Saya berasumsi logikanya adalah membuat transaksi baru setelah transaksi pertama dibatalkan. Dalam ilustrasi Anda, id = 7 dibuat setelah id=3 dibatalkan.

Saya sudah memeriksa di mssql

create table Transactions(id int,account varchar(5),  tp char(1),date_time datetime,amount int)

insert into Transactions values (1,'001','R','2012-01-01 10:01:00',1000)
insert into Transactions values (2,'003','R','2012-01-02 12:53:10',1500)
insert into Transactions values (3,'003','A','2012-01-03 13:10:01',-1500)
insert into Transactions values (4,'002','R','2012-01-03 17:56:00',2000)
insert into Transactions values (5,'001','R','2012-01-04 12:30:01',1000)
insert into Transactions values (6,'002','A','2012-01-04 13:23:01',-2000)
insert into Transactions values (7,'003','R','2012-01-04 15:13:10',3000)


select t.id, t.account, t.date_time, t.amount
from Transactions t
where t.tp = 'R'
and not exists
(
    select account, date_time
    from Transactions
    where tp = 'A'
    and account = t.account
    and t.date_time < date_time
)
person Thit Lwin Oo    schedule 28.02.2012
comment
logika yang anda asumsikan benar, terima kasih atas waktunya :) Sebenarnya jika suatu tempat setelah baris 7 ada baris 'R' lagi untuk akun 003, maka itu juga harus ditampilkan. Namun jika setelah itu dibuat satu baris 'A' lagi untuk akun 003, maka baris baru tersebut tidak akan muncul, namun 7 tetap akan muncul. Izinkan saya mengedit contoh saya untuk mengilustrasikannya. Berdasarkan apa yang Anda ketahui tentang logika yang Anda gunakan pada skrip ini, menurut Anda apakah skrip tersebut harus berperilaku seperti itu? - person Javier Novoa C.; 28.02.2012
comment
Oke, ada baiknya Anda memberikan data ilustrasi yang cukup untuk memenuhi semua keinginan Anda. Ayo coba lagi. - person Thit Lwin Oo; 28.02.2012
comment
Anda benar... Memikirkan masalahnya, dan sejauh yang saya tahu, ini adalah kasus penggunaan terakhir yang perlu saya sertakan... Menguji dengan skrip Anda apa adanya, baris 7 dikecualikan, padahal seharusnya tidak , jadi diperlukan perubahan lebih lanjut :) Mari kita pikirkan... - person Javier Novoa C.; 28.02.2012
comment
Saya mengedit postingan asli, dengan solusi yang saya temukan sendiri, tetapi perlu perbaikan lebih lanjut, kalau-kalau Anda ingin melihatnya... - person Javier Novoa C.; 28.02.2012

arrow_upward
1
arrow_downward

(diedit 2 ) COBA INI:

 SELECT trans.tp as type,
trans.id as id,
 trans.amount as amount, 
trans.date_time as dt, 
trans.account as acct
FROM Transactions trans
WHERE trans.tp = 'R' 
AND trans.account NOT IN (SELECT t.account AS acct
   FROM Transactions t
 WHERE t.date_time > trans.date_time
 AND t.tp = 'A'
AND t.amount = (trans.amount)-((trans.amount)*2)
  ORDER BY t.date_time DESC
 )  ;
person Community    schedule 28.02.2012
comment
mmmm mungkin... hanya ragu... kenapa ‹= di klausa date_time Where? baris 'A' seharusnya ada SETELAH beberapa baris 'R', jadi untuk setiap 'R' yang seharusnya dibatalkan, mungkin ada baris 'A' tetapi tanggalnya akan berada di masa depan 'R ' baris, bukan di masa lalu... - person Javier Novoa C.; 28.02.2012
comment
Jika Anda menghapusnya dari klausa Where, apakah ini akan memberi Anda hasil yang benar? - person prukuhkoo; 28.02.2012
comment
saya hanya perlu mengujinya, saya memiliki banyak data sehingga tesnya tidak mudah. Saya bertanya hanya untuk melihat asumsi di bagian bawah kueri (yang tidak saya lihat saat ini, mungkin saya perlu istirahat;), dan kemudian untuk melihat apakah saya dapat mengujinya lebih lanjut atau membuangnya jika itu benar. yang salah.. - person Javier Novoa C.; 28.02.2012
comment
oke, saya uji hanya dengan data yang saya gunakan pada contoh saya, tetapi tidak muncul baris 7, silakan lihat komentar pada jawaban sebelumnya, saya menambahkan baris 8 dan 9 untuk mencontohkan use case lain :) Terima kasih atas waktunya juga ! (BTW, ‹= salah, seharusnya ›, dengan pengujian sekarang saya dapat mengatakan itu :) - person Javier Novoa C.; 28.02.2012
comment
sudahkah Anda mencoba menghapus t.date_time › trans.date_time di klausa Where pada subkueri? menurutku ini yang menyebabkan masalah bagimu.. - person prukuhkoo; 28.02.2012
comment
coba hapus di permintaan saya sebelumnya.. menurut saya itu akan benar-benar berfungsi.. - person prukuhkoo; 28.02.2012
comment
ya, tapi kenyataannya, hasilnya sama persis dengan klausa itu! setidaknya dengan data sampel... - person Javier Novoa C.; 28.02.2012
comment
Saya mengedit kueri di atas, saya mencobanya dengan data sampel yang diberikan pada jawaban sebelumnya dan berhasil.. hanya menampilkan baris dengan 001 sebagai akun. - person prukuhkoo; 28.02.2012
comment
terima kasih, tapi bukan hanya baris dengan 001 yang harus ditampilkan, tetapi baris yang tidak dibatalkan... Saya sudah mencoba pengeditan ini dengan data sampel saya dan tetap saja baris dengan id 7 (acct 003) tidak muncul, yang mana yang seharusnya... :-/ mungkin saya kurang menjelaskan logika yang saya perlukan? - person Javier Novoa C.; 28.02.2012
comment
hampir! Saya perhatikan Anda menggunakan fakta bahwa jumlahnya negatif untuk setiap pembatalan, tetapi apa yang terjadi jika jumlah di dua baris 'R' untuk akun yang sama adalah sama? katakanlah, jumlah baris 8 juga 3000 seperti pada baris 7 (dan tentu saja jumlah pembatalan baris 9 adalah -3000). Lalu karena kondisi di script anda, baris 7 juga akan dibuang, tapi tidak boleh... Seperti yang saya katakan, hampir! Terima kasih lagi! - person Javier Novoa C.; 28.02.2012
comment
Saya mengedit postingan asli, dengan solusi yang saya temukan sendiri, tetapi perlu perbaikan lebih lanjut, kalau-kalau Anda ingin melihatnya... - person Javier Novoa C.; 28.02.2012

arrow_upward
0
arrow_downward

Jika ID benar-benar sesuai dengan indeks baris ketika diurutkan berdasarkan tanggal_waktu - seperti pada contoh (dan jika tidak, Anda dapat membuat bidang ID seperti itu) - Anda dapat melakukan ini:

SELECT t1.*
FROM transactions t1 JOIN transactions t2 ON(t2.id = t1.id + 1)
WHERE t1.type = 'R'
  AND NOT((t2.type = 'A') AND ((t1.amount + t2.amount) = 0))

yaitu menggunakan kolom ID untuk mendapatkan setiap baris dan penerusnya di baris hasil yang sama; lalu filter properti yang Anda inginkan.

person gcbenison    schedule 28.02.2012
comment
Saya sudah mencoba ini tetapi tidak berhasil. Bahkan dengan data yang saya gunakan sebagai contoh (dan hanya saja, saya mencoba menyederhanakan banyak model saya sehingga hanya inti masalahnya yang ditampilkan di sini), skrip ini menunjukkan baris dengan id 1,4,5,7 tapi dari awal, baris 4 seharusnya tidak muncul. Seperti yang Anda lihat, baris 4 'dibatalkan' di baris 6, tidak langsung di baris 5, jadi menambah id sebanyak 1 tidak berfungsi untuk kasus khusus ini... Bagaimanapun, fakta bahwa id ditampilkan seolah-olah diindeks berdasarkan tanggal adalah hanya artefak dari contoh saya... - person Javier Novoa C.; 28.02.2012
comment
@javier OK Saya melihatnya sekarang - gores pendekatan ini dan lihat jawaban saya yang lebih baru - person gcbenison; 28.02.2012

arrow_upward
0
arrow_downward

Untuk meningkatkan kueri Anda, coba ini:

SELECT t1.*, tFlagged.id AS cancId, tFlagged.tp AS cancFlag FROM t t1
LEFT JOIN t tFlagged
ON t1.account = tFlagged.account AND t1.date_time < tFlagged.date_time
WHERE t1.tp = 'R' 
GROUP BY t1.id
HAVING tFlagged.tp is null or tFlagged.tp <> 'A'

Ini akan berjalan lebih cepat... semoga memberikan hasil yang sama :P

person Mosty Mostacho    schedule 28.02.2012
comment
kueri untuk solusinya bahkan tidak memiliki kondisi itu... dan yang benar dengan kondisi serupa memerlukannya untuk memfilter data dalam gabungan dengan benar... - person Javier Novoa C.; 28.02.2012
comment
oke... izinkan saya mengujinya secara mendalam dengan data saya yang sebenarnya. Kuerinya sangat cepat dibandingkan dengan yang saya miliki, tetapi memberi saya jumlah baris hasil yang berbeda, jadi saya harus menganalisisnya terlebih dahulu... Terima kasih! - person Javier Novoa C.; 28.02.2012