1c 8 tabel virtual.

Artikel tersebut menjelaskan implementasi fisik dari tabel virtual residu konfigurasi yang beroperasi dalam mode operasi klien-server menggunakan DBMS MS sebagai contoh. Server SQL.

Penerapan

Artikel ini membahas 1C: Platform perusahaan versi 8.3.5.1383. Dalam versi platform saat ini, beberapa perubahan dimungkinkan dalam teks yang dijelaskan dalam materi, permintaan T-SQL dieksekusi di sisi server DBMS.

Perangkat tabel residu virtual

Mari kita pertimbangkan kueri seperti apa ke DBMS kueri yang diubah menjadi menggunakan tabel virtual saldo daftar akumulasi. Misalnya, teks permintaan berikut akan dipertimbangkan:

MEMILIH
CommodityStocksRemains.Commodity,
CommodityStocksRemains.Warehouse,
CommodityStocksRemains.QuantityRemains
DARI
Daftar Akumulasi Stok Komoditas Saldo(&Tanggal , Gudang = &Gudang ) BAGAIMANA
Stok KomoditasSisa

Pertama dengan metode konteks global GetDatabaseStorageStructure() dapatkan daftar tabel database yang menyimpan data register akumulasi "Saham Komoditi":

Komposisi bidang tabel utama register akumulasi dan tabel total diberikan di bawah ini:

Menyimpan total untuk daftar ini dikonfigurasi dalam mode 1C:Enterprise 8 sebagai berikut:

Isi parameter dalam permintaan yang dimaksud sebagai berikut:


Platform mengubah teks permintaan menjadi permintaan berikut, yang akan dijalankan di server DBMS:

PILIH
Q_000_T_001.Fld82 ,
Q_000_T_001.Fld83 ,
Q_000_T_001.Fld84Saldo
DARI
(PILIH Fld82 ,
lapangan83,

DARI
(PILIH Fld82 ,
lapangan83,
SUM (Fld84 ) AS Fld84Saldo
DARI AccumRgT85
DI MANA Periode = DATETIME (3999 , 11 , 1 )
DAN ((Fld83 = ))
DAN (Fld84<>0 ) DAN (Fld84<> 0 )
KELOMPOK DENGAN Fld82 , Fld83
MEMILIKI Saldo Lapangan84<> 0
UNI SEMUA
PILIH Lapangan82 ,
lapangan83,
JUMLAH (KASUS KETIKA RecordKind = 0 KEMUDIAN - Fld84 LAIN Fld84 AKHIR) SEBAGAI Fld84Balance
DARI AccumRg81
WHERE Periode >= DATETIME (2012 , 9 , 1 )
DAN Periode< DATETIME (3999 , 11 , 1 )
DAN Aktif
DAN ((Fld83 = 9:))
KELOMPOK DENGAN Fld82 , Fld83
MEMILIKI Saldo Lapangan84<>0 ) T
KELOMPOK DENGAN Fld82 , Fld83
MEMILIKI Saldo Lapangan84<>0) Q_000_T_001

Mari kita menganalisis permintaan yang diterima lebih terinci.

Pertama, menggunakan kueri pertama yang disertakan dalam gabungan, data dipilih dari tabel AccumRgT85 yang dihasilkan. Total diperoleh pada tanggal penyimpanan total saat ini (11/01/3999), kondisi tambahan dikenakan pada bidang Gudang (karena kondisi seperti itu digunakan dalam parameter tabel virtual). Selain itu, pemeriksaan dilakukan untuk tidak adanya baris dengan sisa nol pada hasilnya.

Harap perhatikan bahwa pengelompokan dilakukan sesuai dengan dimensi yang dipilih dalam teks kueri. Itulah mengapa teks dalam 1C: Bahasa kueri perusahaan tidak memerlukan pengelompokan tambahan berdasarkan dimensi.

Kueri gabungan kedua menggunakan tabel gerakan register AccumRg81. Bergantung pada jenis gerakannya (jika RecordKind sama dengan 0, maka ini adalah Inflow, jika tidak - Outflow), sebuah tanda dimasukkan ke dalam ekspresi. Platform memilih data untuk periode dari tanggal yang ditentukan sebagai parameter tabel virtual hingga tanggal total saat ini disimpan (01.11.3999).

Selain itu, hanya record aktif yang dipilih, field Warehouse harus sama dengan nilai yang ditentukan. Seperti kueri gabungan pertama, ini juga mengelompokkan berdasarkan dimensi yang dipilih dan membuang rekaman dengan nilai sumber daya nol.

Jika DBMS MS SQL Server digunakan dan offset tanggal 2000 ditetapkan untuk database, maka semua tanggal akan disimpan dengan offset yang ditentukan, yaitu. bukannya 11/01/3999 Anda akan melihat 11/01/5999.

Jika Anda menonaktifkan total saat ini untuk register akumulasi, platform pertama akan menerima total terbaru yang dihitung pada tanggal lebih awal dari yang ditentukan dalam parameter Periode tabel virtual.

Kemudian, demikian pula, data ini akan ditambahkan dari tabel pergerakan, tetapi hanya untuk periode dari tanggal penjumlahan terakhir hingga periode tabel virtual.

PILIH
Q_000_T_001.Fld82 ,
Q_000_T_001.Fld83 ,
Q_000_T_001.Fld84Saldo
DARI
(PILIH Fld82 ,
lapangan83,
SUM (Fld84Balance ) SEBAGAI Fld84Saldo
DARI
(PILIH Fld82 ,
lapangan83,
SUM (Fld84 ) AS Fld84Saldo
DARI AccumRgT85
DI MANA Periode = DATETIME(2012 , 4 , 1 )
DAN ((Fld83 = 9:))
DAN (Fld84<> 0 )
DAN (Fld84<> 0 )
KELOMPOK DENGAN Fld82 , Fld83
MEMILIKI Saldo Lapangan84<> 0
UNI SEMUA
PILIH Lapangan82 ,
lapangan83,
JUMLAH (KASUS KETIKA RecordKind = 0 KEMUDIAN Fld84 ELSE - Fld84 END ) SEBAGAI Fld84Balance
DARI AccumRg81
WHERE Periode >= DATETIME (2012 , 4 , 1 )
DAN Periode< DATETIME (2012 , 9 , 1 )
DAN Aktif
DAN ((Fld83 = 9:))
KELOMPOK DENGAN Fld82 , Fld83
MEMILIKI Saldo Lapangan84<>0 ) T
KELOMPOK DENGAN Fld82 , Fld83
MEMILIKI Saldo Lapangan84<>0) Q_000_T_001

Perhatikan kondisi berikut di badan permintaan.

Jika postingan saya bermanfaat untuk anda, jangan lupa upvote :-)

Berikut adalah rubrikator untuk semua tugas koleksi(halaman dengan tautan ke utas forum untuk setiap tugas)
http://chistov.spb.ru/forum/16-969-1

Nah, sekarang perkembangan dan catatan saya yang saya buat dalam proses persiapan.
Saya akan mencoba mengulang minimal dengan dua yang disebutkan di atas terakhir publikasi.

Jadi mari kita mulai:


Dalam hal pengiriman jarak jauh, Anda harus memiliki dua objek di desktop pada akhir ujian:

1. Unggahan terakhir basis informasi(berkas dt)
2. Catatan penjelasan

Seharusnya tidak ada yang lain, tidak ada salinan perantara, dll.

Pastikan untuk menulis catatan penjelasan!
Dalam kasus tugas yang dirumuskan secara samar, pastikan untuk menulis di sana bahwa Anda telah memilih solusi ini dan itu.
Juga dalam kode di tempat-tempat utama, lebih baik meninggalkan komentar singkat, tanpa fanatisme, tetapi jika penguji mungkin memiliki pertanyaan, lebih baik menulis.

Tetapi Anda akan diberitahu tentang hal ini dalam instruksi yang akan Anda baca sebelum ujian.
Lebih baik tahu sebelumnya)


Menggunakan kueri tanda ampersand.

Terkadang lebih cepat untuk melakukan panggilan keyboard tambahan daripada beralih bolak-balik tata letak menghemat waktu
&=Alt+38

*************************************************************************************************
Menggunakan MomentTime() di Query

Dalam kueri ke register akumulasi, akuntansi, sebagai parameter tabel virtual (periode), perlu menggunakan bukan tanggal dokumen, tetapi parameter Momen, yang didefinisikan dalam kode sebagai berikut:

Momen = ?(PostMode = PostModeDocument.Online, Undefined, MomentTime());

*************************************************************************************************
Saat membuat perpindahan dokumen dengan register, pada awal prosedur pemrosesan posting, perlu untuk menghapus pergerakan dokumen saat ini dengan register.

Kodenya seperti ini:

Movements.RegisterName.Write = Benar; Movements.RegisterName.Clear();

Ada kemungkinan bahwa dalam proses pelaksanaannya perlu dilakukan analisis terhadap catatan-catatan dalam register ini.
Sehingga saat menganalisis catatan saat ini (yang lama, sebelum dokumen diubah) tidak benar-benar masuk dalam pilihan, Anda dapat menambahkan satu baris lagi ke dua baris di atas:

Movements.RegisterName.Write();

Atau, saat mem-parsing rekaman, secara eksplisit tentukan batas yang tidak menyertakan momen dalam waktu dokumen saat ini.

Tapi di mana-mana saya hanya menunjukkan konstruksi tiga baris ini sekaligus:

Movements.RegisterName.Write = Benar; Movements.RegisterName.Clear(); Movements.RegisterName.Write();

*************************************************************************************************
Ada dua cara untuk memblokir data, pilihan di antara keduanya bergantung pada metode pelaksanaan - lama atau baru:

1) Penguncian terkelola konvensional, metode lama untuk memposting dokumen (objek DataLock)

Diatur jika saldo diperiksa terlebih dahulu, dan kemudian dihapuskan.
Dalam hal kita perlu memiliki beberapa informasi dari register untuk membentuk gerakan.

Contoh:

Dalam dokumen - kuantitas, dalam register - kuantitas dan jumlah (biaya)
Jadi, kami tahu jumlah barang dari dokumen - berapa banyak yang kami hapus, tetapi harga biayanya - tidak.
Kita dapat mempelajarinya hanya dari register, tetapi agar tidak ada yang mengubah register antara saat menerima saldo dan saat mencatat pergerakan, kita perlu memblokir register bahkan sebelum membaca saldo.
Jadi, dalam hal ini, objek DataLock digunakan. Dan saat membuatnya, lebih tepat untuk menunjukkan dengan dimensi mana kami memblokir register (misalnya, dalam kasus kami - hanya dengan nomenklatur yang ditentukan dalam dokumen) - sehingga tidak ada kunci yang tidak perlu dan pengguna lain dapat menjual nomenklatur lain.


1. Setel kunci menggunakan objek DataLock
2. Baca sisanya
3. Memeriksa kemungkinan pendebetan
4. Kami membentuk gerakan, misalnya kami mencoret barang
5. Setelah dokumen diposting, pemblokiran secara otomatis dilepaskan (pemblokiran berlaku dalam rangka transaksi posting dan dilepaskan secara otomatis oleh sistem). Artinya, tidak perlu membuka kunci objek secara khusus.

2) Metodologi baru untuk melakukan dokumen (menggunakan properti LockForChange = True)

Ini digunakan jika kita tidak memerlukan informasi dari register untuk membentuk pergerakan, dan kita dapat memeriksa apakah kita telah menjadi merah saat mendebet, jika setelah mencatat kita melihat saldo register dan melihat ada yang negatif. Dalam hal ini, kami akan memahami bahwa kami telah menghapus kelebihan dan membatalkan operasi penghapusan.

Contoh:
Pertimbangkan operasi penjualan barang.
Dalam dokumen - kuantitas, dalam register - hanya kuantitas
Jadi, kita tahu kuantitas barang dari dokumen tersebut.
Kami membentuk gerakan dengan nomor yang ditentukan dalam dokumen dan mencatatnya. Selanjutnya kita baca registernya, lihat sisanya, analisa apakah ada yang negatif. Jika ada, kami menampilkan kesalahan dan menyetel Penolakan = Benar.

Jadi urutannya adalah:
1. Untuk menelusuri register, setel properti LockForChange = True
2. Kami membentuk gerakan - kami menghapus barang
3. Rekam gerakannya
4. Baca register, pastikan tidak ada saldo negatif. Jika ada, maka kelebihannya dihapuskan, jika tidak, maka semuanya baik-baik saja.

Jadi, dalam hal ini, tidak perlu menunjukkan dimensi mana yang perlu kita blokir registernya.
Kami cukup mengatur properti BlockToChange = True sebelum merekam gerakan kami, membentuk gerakan dan merekam.
Sistem itu sendiri akan memblokir register pada saat pencatatan sesuai dengan pengukuran yang dibutuhkan, setelah menganalisa apa yang telah kita rekam.
Setelah selesai, kunci akan dihapus.

Opsi ini (yang kedua) lebih sederhana, ini disebut "metode baru untuk melakukan dokumen" dan 1C merekomendasikan untuk menggunakannya jika memungkinkan dan mengurangi poin jika opsi pertama digunakan, tetapi dalam beberapa kasus opsi ini tidak dapat diterapkan dan yang pertama opsi digunakan dengan objek Data Lock (lihat di bawah).contoh di atas).

Saya juga mencatat bahwa terlepas dari metode yang dipilih, gerakan harus dibersihkan sebelum mengerjakannya (lihat tip sebelumnya)

*************************************************************************************************
Pemblokiran data (metode pemblokiran No. 1 dari uraian di atas)

Penguncian terkontrol diperlukan saat data dibaca dan gerakan dibuat berdasarkan data ini
Cara tercepat untuk mendapatkan kode kunci terkelola adalah dengan mengetik "DataLock", panggil Pembantu Sintaks, dan dari sana cukup salin kode contoh. Maka mudah untuk mengubahnya dengan nama register dan pengukuran Anda.

Terlihat seperti ini:

Kunci = DataLock Baru; LockElement = Lock.Add("Pendaftaran Akumulasi.GoodsInWarehouses"); LockItem.Mode = DataLockMode.Exclusive; LockItem.DataSource = PM; LockElement.UseFromDataSource("Nomenklatur", "Nomenklatur"); Kunci.Kunci();

*************************************************************************************************
Bagian tabular dari dokumen lebih baik disebut "PM" saja

Bagian tabular dalam 99% dokumen adalah satu. Nama yang begitu bersatu bagian tabular Ini akan membantu Anda menghemat banyak waktu karena:
1) Sangat pendek - tulis dengan cepat
2) Sama untuk semua dokumen, Anda tidak perlu mengingat saat menulis kode apa namanya

*************************************************************************************************
Periksa hasil permintaan kekosongan sebelum memilih atau mengunggah ke TK.

Secara umum, saya menggunakan pengambilan sampel di semua tugas.

Sampel lebih optimal untuk sistem dalam hal kinerja, karena "dipertajam" hanya untuk membaca data (tidak seperti TK).

Tetapi bagaimanapun juga, sebelum metode Select(), lebih baik untuk memeriksa hasil permintaan kekosongan, ini selanjutnya akan mengurangi beban pada sistem.

Hasil = Permintaan.Jalankan(); Jika Bukan Hasil.Kosong() Maka Pilihan = Hasil.Pilih(IteratingQueryResult.By Pengelompokan); ... Berakhir jika;

Dan seandainya kita hanya perlu mendapatkan satu nilai dari permintaan
(misalnya, hanya metode penghapusan sesuai dengan kebijakan akuntansi ditetapkan untuk tahun ini):

Hasil = Permintaan.Jalankan(); Jika Bukan Hasil.Kosong() Kemudian Pilihan = Hasil.Pilih(); Seleksi.Berikutnya(); Metode Penghapusan Biaya = Contoh Metode Penghapusan Biaya; Berakhir jika;

*************************************************************************************************
Dokumen "Operasi" untuk tugas BU

Pastikan untuk membuat dokumen Operasi untuk tugas BU.

Kami mematikan konduksinya secara umum (di properti "Melakukan = Tolak"), kami menunjukkan apa yang membuat pergerakan dalam register akuntansi, kami menarik pergerakan pada formulir.

*************************************************************************************************
Pemrosesan operasional dokumen:

Harus termasuk:
Dalam operasional dan akuntansi. akuntansi untuk dokumen harus diaktifkan (kecuali untuk dokumen "Operasi", lihat di bawah).

Harus matikan:
dalam tugas perhitungan tidak masuk akal untuk dokumen penggajian.

Untuk dokumen "Operasi", posting harus dinonaktifkan secara umum (di properti dokumen "Post = Disable"),
karena menulis hanya menulis data langsung ke register saat menulis.

*************************************************************************************************
Kondisikan dalam kueri seperti "Entah nomenklatur yang ditentukan atau apa pun, jika tidak ditentukan"

Dalam kueri, ada tugas seperti itu: misalnya, Anda perlu memilih dokumen dengan nomenklatur yang ditentukan atau semua dokumen jika nomenklatur tidak ditentukan.
Itu diselesaikan dengan kondisi berikut dalam permintaan itu sendiri:

Nomenklatur = &Nomenklatur ATAU &Nomenklatur = Nilai(Catalog.Nomenclature.EmptyReference)

Tetapi akan lebih optimal dan benar untuk mengubah kondisi ini (terima kasih yukon):


Query.Text = Query.Text + " WHERE Nomenklatur = &Nomenklatur";

Berakhir jika;

Dengan munculnya model objek kueri di 8.3.5, akan lebih aman untuk menambahkan kondisi:

If ValueFilled(Nomenclature) Then
Query1.Filter.Add("Nomenklatur = &Nomenklatur");
Query.SetParameter("Nomenklatur", Nomenklatur);
Berakhir jika;

*************************************************************************************************
Menggabungkan tabel dalam kueri:

Jumlah catatan total tidak bergantung pada apakah bidang tabel terlampir akan ditampilkan, itu hanya bergantung pada tautan yang dikonfigurasi.
Artinya, bidang tabel terlampir mungkin tidak ditampilkan.

Jika Anda ingin melampirkan tabel tanpa kondisi apa pun, maka pada tab kondisi cukup tulis kondisi "BENAR".
Dalam hal ini, tabel akan bergabung dengan tepat.

*************************************************************************************************
Menggunakan rencana jenis karakteristik (PVC):

1. Gunakan sebagai mekanisme untuk mendeskripsikan karakteristik objek.

1.1. Kami membuat PVC. Ini akan menjadi Jenis Fitur (mis. warna, ukuran, kecepatan maks., dll.). Dalam pengaturan, pilih semua kemungkinan jenis nilai karakteristik dan, jika perlu, buat objek dari paragraf 1.2 dan tentukan juga dalam pengaturan.

1.2. Untuk nilai PVC tambahan, kami membuat direktori ExtraValues ​​​​dari Karakteristik (atau hanya Nilai Karakteristik) di bawahnya.
Karakteristik akan disimpan di dalamnya jika tidak ada di direktori yang ada. Kami tidak dapat membuatnya jika semua karakteristik yang kami butuhkan ada di direktori yang ada, atau nilai-nilai ini dapat diwakili oleh tipe data dasar. Dalam pengaturan PVC, kami menunjukkan bahwa direktori ini akan digunakan untuk tambahan. nilai-nilai karakteristik.

1.3. Kami membuat daftar informasi, yang sebenarnya menghubungkan tiga objek:
- Objek yang kita hubungkan dengan mekanisme karakteristik
- Jenis Karakteristik (jenis PVC)
- Nilai karakteristik (tipe - karakteristik, ini adalah tipe baru yang muncul di sistem setelah pembuatan PVC
dan menjelaskan semua kemungkinan tipe data yang dapat diambil oleh nilai karakteristik).
Dalam register informasi, kami menunjukkan bahwa Tipe Karakteristik adalah pemilik Nilai Karakteristik (hubungan parameter pemilihan), serta hubungan tipe untuk Nilai Karakteristik, sekali lagi dari Tipe Karakteristik.

Fitur lainnya adalah untuk setiap jenis karakteristik yang dibuat, Anda dapat menentukan jenis nilai dari karakteristik tersebut, jika Anda tidak memerlukan semua jenis yang mungkin untuk mendeskripsikan nilai dari karakteristik ini.

2. Menggunakan PVC untuk membuat mekanisme subconto register akuntansi .

2.1. Kami membuat Subconto Jenis PVC.

2.2. Kami membuat direktori subconto Nilai Subconto (seperti dengan karakteristik, itu akan berisi nilai subconto jika tidak ada di direktori lain).

2.3. Koneksi dibuat menggunakan bagan akun.

*************************************************************************************************
Sumber daya register akuntansi:

Jumlah - saldo,
Kuantitas - off-balance sheet dan terkait dengan tanda akuntansi Kuantitatif

*************************************************************************************************
Tabel virtual register akuntansi:

Omset: omset satu akun
PerputaranDtKt: perputaran antara dua akun, yaitu semua transaksi yang sama untuk periode tersebut.

*************************************************************************************************
Akuntansi mata uang pada register akuntansi - cara menerapkan:

Kami membuat tanda "mata uang" akuntansi di bagan akun.
Dalam register akuntansi, kami juga membuat:
- Dimensi mata uang (larangan nilai kosong, non-neraca, tanda akuntansi - mata uang)
- Sumber daya CurrencyAmount (non-neraca, tanda akuntansi - mata uang, itu akan menyimpan jumlah dalam mata uang, yaitu $ 100 misalnya)
Semua.

Dengan demikian struktur register:

Pengukuran:
- Mata uang
Sumber daya
- Kuantitas
- Jumlah (jumlah dalam rubel)
- CurrencyAmount (jumlah dalam mata uang)

Dengan demikian, akuntansi mata uang hanyalah penyempurnaan dari akuntansi biasa di Republik Belarus, tidak mengubah esensi, misalnya jumlah sumber daya
(di sana, seperti biasa, jumlahnya dalam rubel, terlepas dari apakah akun tersebut dalam mata uang asing atau tidak).
Dan jika atribut akuntansi mata uang untuk akun dimatikan, maka ini adalah struktur biasa Republik Belarus (sumber daya - hanya kuantitas dan jumlah).

*************************************************************************************************
Saat menyetel parameter tabel virtual untuk mendapatkan bagian dari yang terakhir, kami menerapkan ketentuan pada dimensi, dan bukan pada sumber daya.

Jika tidak, kami tidak akan mendapatkan bagian dari yang terbaru, tetapi catatan terakhir dengan nilai sumber daya yang ditentukan - ini mungkin bukan yang terakhir dalam rangkaian pengukuran

*************************************************************************************************
Arti dari sumber daya dan atribut dalam register perhitungan

Dalam register kalkulasi, pembuatan sumber daya memungkinkan untuk menerimanya saat menghitung basis untuk register ini.
Dan bahkan sebanding dengan periode yang diberikan, nilai sumber daya akan dihitung ulang (jika periode dasar tidak sesuai dengan frekuensi register).

Dan nilai atribut hanya tersedia di tabel nyata dari register perhitungan, bukan di tabel virtual.

*************************************************************************************************
Kotak centang "Dasar" di properti dimensi register perhitungan
Artinya, basis untuk dimensi ini akan diperoleh di masa mendatang dan berfungsi untuk pengindeksan nilai tambahan untuk bidang ini.

*************************************************************************************************
Perincian masa berlaku cuti per bulan pada saat penulisan register record set,
jika liburan ditentukan dalam dokumen dalam satu baris selama beberapa bulan sekaligus dalam satu baris:

StartDateCurMonth = StartMonth(CurStringBasicAccruals.ActionPeriodStart); EndDateCurMonth = EndMonth(CurStringBasicAccruals.ActionPeriodStart); Bulan Sekarang = Tanggal; Berdasarkan TanggalBeginTecMonth<= НачалоМесяца(ТекСтрокаОсновныеНачисления.ПериодДействияКонец) Цикл Движение = Движения.ОсновныеНачисления.Добавить(); Движение.Сторно = Ложь; Движение.ВидРасчета = ТекСтрокаОсновныеНачисления.ВидРасчета; Движение.ПериодДействияНачало = Макс(ДатаНачалаТекМесяца, ТекСтрокаОсновныеНачисления.ПериодДействияНачало); Движение.ПериодДействияКонец = КонецДня(Мин(ДатаОкончанияТекМесяца, ТекСтрокаОсновныеНачисления.ПериодДействияКонец)); Движение.ПериодРегистрации = Дата; Движение.Сотрудник = ТекСтрокаОсновныеНачисления.Сотрудник; Движение.Подразделение = ТекСтрокаОсновныеНачисления.Подразделение; Движение.Сумма = 0; Движение.КоличествоДней = 0; Движение.График = ТекСтрокаОсновныеНачисления.График; Движение.Параметр = ТекСтрокаОсновныеНачисления.Параметр; Движение.БазовыйПериодНачало = НачалоМесяца(ДобавитьМесяц(Дата, -3)); Движение.БазовыйПериодКонец = КонецДня(КонецМесяца(ДобавитьМесяц(Дата, -1))); ДатаНачалаТекМесяца = НачалоМесяца(ДобавитьМесяц(ДатаНачалаТекМесяца, 1)); ДатаОкончанияТекМесяца = КонецМесяца(ДатаНачалаТекМесяца); КонецЦикла; КонецЕсли;

*************************************************************************************************
Membangun Bagan Gantt:

Kami menempatkan elemen tipe "Gantt Chart" pada formulir, beri nama DG, lalu buat perintah "Hasilkan" dan tulis yang berikut ini di modul formulir:

&Prosedur AtClient Hasilkan(Perintah) HasilkanDiServer(); EndProcedure &AtServer Procedure GenerateAtServer() DG.Clear(); DG.Perbarui = Salah; Запрос = Новый Запрос("ВЫБРАТЬ |ОсновныеНачисленияФактическийПериодДействия.Сотрудник, |ОсновныеНачисленияФактическийПериодДействия.ВидРасчета, |ОсновныеНачисленияФактическийПериодДействия.ПериодДействияНачало КАК ПериодДействияНачало, |ОсновныеНачисленияФактическийПериодДействия.ПериодДействияКонец КАК ПериодДействияКонец |ИЗ |РегистрРасчета.ОсновныеНачисления.ФактическийПериодДействия КАК ОсновныеНачисленияФактическийПериодДействия |ГДЕ |ОсновныеНачисленияФактическийПериодДействия.ПериодДействия МЕЖДУ &ДатаНачала И &ДатаОкончания "); Query.SetParameter("StartDate", Periode.StartDate); Query.SetParameter("EndDate", Periode.EndDate); Pilihan = Query.Execute().Select(); Sedangkan Sample.Next() Loop Point = DG.SetPoint(Selection.Employee); Seri = DG.SetSeries(Seleksi.Jenis Perhitungan); Nilai = DG.GetValue(Titik, Seri); Interval = Nilai.Tambah(); Interval.Start = Contoh.PeriodActionStart; Interval.End = Sample.PeriodActionEnd; Akhir Siklus; DG.Perbarui = true; Prosedur Akhir

Sebenarnya, hanya kode dalam loop yang penting bagi kami di sini, hal-hal lainnya bersifat tambahan, saya baru saja membawa seluruh implementasi subtugas ini.
Dalam permintaan, penting bagi kami bahwa ada karyawan, jenis perhitungan, tanggal mulai dan tanggal akhir periode.
Kodenya sebenarnya sangat sederhana, mudah diingat, jangan khawatir jika terlihat rumit

*************************************************************************************************
Memproses catatan "storno" dalam tugas penyelesaian:

Dalam prosedur pemrosesan posting (modul objek), kami membentuk semua gerakan, dan kemudian jika ada catatan di periode lain, kami akan mendapatkannya seperti ini
(sistem membuatnya secara otomatis - membantu kami):

RecordsAdditions = Movements.BasicAccruals.GetAdditions(); // Kamu tidak perlu merekam gerakan untuk mendapatkan komplemen

Untuk Setiap TekLine Dari RecordAddition Loop
Rekam = Movements.BasicAccruals.Add();
FillPropertyValues(Record, CurrentString);
Record.RegistrationPeriod = CurrentString.RegistrationPeriodStorno;
Record.ActionPeriodStart = CurrentString.ActionPeriodStartReverse;
Record.ActionPeriodEnd = CurrentString.ActionPeriodEndReverse;
Siklus Akhir

Dan saat menghitung catatan, masukkan cek:

Jika CurrentMovement.Reversal Kemudian
CurrentMovement.Jumlah = - CurrentMovement.Jumlah;
Berakhir jika;

*************************************************************************************************
Bagaimana menentukan apa yang harus dimasukkan dalam akrual utama, dan apa - tambahan dalam tugas perhitungan.

Tapi ini tidak selalu 100% jelas, ada kasus yang lebih rumit, meski jumlahnya cukup banyak.
(Misalnya, bonus yang tergantung pada jumlah hari kerja dalam sebulan adalah OH).

Akrual dasar:
Jika menurut jenis perhitungan ada ketergantungan pada jadwal (artinya daftar informasi dengan tanggal kalender), maka itu mengacu pada akrual utama.

OH contoh:
- Gaji
- Sesuatu yang dihitung dari jumlah hari kerja (dan untuk ini Anda perlu menggunakan jadwal): baik dalam masa berlaku (sebagai gaji) atau dalam masa dasar

Biaya tambahan:
Apa yang dianggap baik dari jumlah yang masih harus dibayar, atau BEKERJA (dan bukan norma!) Waktu, atau tidak tergantung sama sekali - ini tambahan. biaya.

Yaitu: akrual untuk perhitungan yang menggunakan norma waktu (mungkin juga fakta) adalah OH, dan yang membutuhkan data aktual atau tidak sama sekali - ini adalah DN.

Atau dengan kata lain:

Jika RT menggunakan norma waktu, maka harus dicantumkan masa berlaku RT tersebut.

*************************************************************************************************
Tambahkan opsi dalam bentuk daftar buku referensi "Nomenklatur" kemampuan untuk membuka bagian bantuan bawaan "Bekerja dengan buku referensi".

Jalankan perintah berikut pada formulir:

&Pada Klien
Bantuan Prosedur (Perintah)
OpenHelp("v8help://1cv8/EnterprWorkingWithCatalogs");
Prosedur Akhir

Garis bagian didefinisikan sebagai berikut:
Buka informasi referensi objek konfigurasi (di konfigurator), tulis kata, pilih, buka menu Elemen / Tautan dan pilih bagian bantuan 1C yang diinginkan, setelah itu tautan dimasukkan secara otomatis. Kelihatannya rumit, tapi prakteknya mudah.

*************************************************************************************************
Implementasi interaksi antar bentuk, misalnya pemilihan:

1. Dari formulir saat ini, buka yang diperlukan menggunakan metode "OpenForm()", sebagai parameter kedua kami meneruskan struktur dengan parameter (jika perlu). Sebagai parameter ketiga, kita dapat mengirimkan link ke form ini - ThisForm.

2. Dalam formulir terbuka di handler "OnCreateOnServer()", kita dapat menangkap parameter yang diteruskan di langkah 1 melalui "Parameters.[NamaParameter]". Formulir yang menginisialisasi pembukaan formulir ini akan tersedia melalui pengidentifikasi "Pemilik" (jika, tentu saja, ditentukan dalam paragraf 1).

Dan yang terpenting, fungsi ekspor dari formulir pemilik akan tersedia. Artinya, kita dapat memanggil fungsi ekspor dari bentuk aslinya dan mengirimkan sesuatu ke sana sebagai parameter untuk memproses pemilihan. Dan fungsi ini sudah mengisi apa yang Anda butuhkan di formulir aslinya. Hanya satu peringatan - Anda tidak dapat mentransfer tabel nilai antara prosedur klien, tetapi kami dapat menyimpannya di penyimpanan sementara dan mentransfer hanya alamat BX, lalu mengekstraknya dari BX.

*************************************************************************************************
Siklus hidup parameter bentuk

Semua parameter yang diteruskan ke formulir pada saat dibuka hanya dapat dilihat dalam prosedur OnCreateOnServer.
Setelah pembuatan, semua parameter dihancurkan dan tidak lagi tersedia dalam formulir.
Pengecualian adalah parameter yang dideklarasikan di editor formulir dengan atribut "Parameter kunci".
Mereka menentukan keunikan bentuk.
Parameter seperti itu akan ada selama bentuk itu sendiri ada.

*************************************************************************************************
Menggunakan antarmuka Taksi

Selama pengembangan, Anda dapat menyetel antarmuka terkelola biasa 8.2 di properti konfigurasi - dengan cara ini semuanya terasa lebih ringkas dan familier.
Ini terutama benar jika Anda menyewa dari jarak jauh - resolusi layar sangat kecil, tidak mungkin melakukan apa pun dengan antarmuka "taksi".
Jangan lupa setelah semuanya selesai, pasang "Taksi" lagi!Jika tidak, penguji akan menghapus poin!

*************************************************************************************************

PS:E Ada subtugas tipikal terpisah yang digunakan di semua tugas, dan subtugas itulah yang harus Anda selesaikan (misalnya, menghapus secara batch, menggunakan PVC (yah, ini sangat jarang) dan lainnya). Dan dalam semua tugas mereka hanya diulang (di suatu tempat ada beberapa subtugas, di suatu tempat yang lain, hanya dalam kombinasi yang berbeda). Selain itu, koleksi tersebut telah lama dijanjikan untuk merilis yang baru (jika belum dirilis), di mana seharusnya ada lebih banyak masalah, yaitu tidak masuk akal untuk menghafal solusi untuk masalah individu, itu masuk akal. untuk mempelajari cara menyelesaikan subtugas tipikal individu, maka Anda akan menyelesaikan masalah apa pun.

PSS: Rekan-rekan, jika ada yang punya informasi berguna tentang persiapan ujian dan kelulusan, silakan tulis di komentar, kami akan melengkapi artikelnya.

Saya memutuskan untuk berkontribusi dan menjelaskan fitur-fitur bahasa yang tidak dipertimbangkan dalam artikel di atas. Artikel ini ditujukan untuk pengembang pemula.

1. Konstruksi "DARI".

Untuk mendapatkan data dari database, tidak perlu menggunakan konstruk "FROM".
Contoh: Kita perlu memilih semua informasi tentang bank dari direktori bank.
Meminta:

PILIH Direktori.Banks.*

Memilih semua bidang dari direktori Banks. Dan mirip dengan kueri:

PILIH Bank.* DARI Direktori Bank AS Bank

2. Pesan data berdasarkan bidang referensi

Ketika kita perlu memesan data kueri berdasarkan tipe primitif: "String", "Number", "Date", dll., maka semuanya diselesaikan dengan menggunakan konstruksi "ORDER BY", jika Anda perlu memesan data dengan bidang referensi? Bidang referensi adalah tautan, pengidentifikasi unik, mis. Secara kasar, sekumpulan karakter tertentu yang sewenang-wenang dan urutan yang biasa mungkin tidak memberikan hasil yang diharapkan. Untuk mengurutkan kolom referensi, konstruk "AUTOORDER" digunakan. Untuk melakukannya, pertama-tama Anda harus mengurutkan data secara langsung berdasarkan tipe referensi menggunakan konstruk "ORDER BY", lalu konstruk "AUTOORDER".

Dalam hal ini, untuk dokumen, pengurutan akan terjadi dalam urutan "Tanggal-> Nomor", untuk direktori - menurut "Tampilan utama". Jika pengurutan tidak didasarkan pada bidang referensi, maka penggunaan konstruksi "AUTOORDER" tidak disarankan.

Dalam beberapa kasus, konstruk "AUTOORDER" dapat memperlambat proses pengambilan sampel. Demikian pula, Anda dapat menulis ulang tanpa mengatur dokumen secara otomatis:

3. Memperoleh representasi tekstual dari jenis referensi. konstruksi "PRESENTASI".

Saat Anda perlu menampilkan bidang jenis referensi untuk ditampilkan, misalnya, bidang "Bank", yang merupakan tautan ke elemen direktori "Bank", Anda perlu memahami bahwa saat bidang ini ditampilkan, subkueri ke Direktori "Banks" akan dijalankan secara otomatis untuk mendapatkan pencarian direktori. Ini akan memperlambat output data. Untuk menghindari hal ini, perlu menggunakan konstruk "REPRESENTASI" dalam permintaan untuk segera mendapatkan representasi objek dan sudah menampilkannya untuk dilihat.

Dalam sistem komposisi data, mekanisme ini digunakan secara default, tetapi saat membuat tata letak dalam sel, Anda harus menentukan representasi bidang referensi, dan misalnya, meletakkan tautan itu sendiri dalam transkrip.

4. Ketentuan pengambilan sampel data sesuai template.

Misalnya, Anda perlu mendapatkan ponsel karyawan dengan formulir (8 -123-456-78-912). Untuk melakukan ini, Anda harus memasukkan kondisi berikut dalam permintaan:

PILIH Employee.Name, Employee.Phone AS Phone FROM Directory.Employees AS Employees WHERE Phone LIKE "_-___-___-__-__"

Karakter "_" adalah layanan dan menggantikan karakter apa pun.

5. Penggunaan penjumlahan dan pengelompokan secara bersamaan.


Total sering digunakan bersamaan dengan pengelompokan, dalam hal ini fungsi agregat dalam total dapat dihilangkan.

PILIH Layanan.Organisasi AS Organisasi, Layanan.Nomenklatur AS Nomenklatur, SUM(Layanan.Jumlah Dokumen) AS Jumlah Dokumen DARI Dokumen.Layanan AS KELOMPOK Layanan BERDASARKAN Layanan.Organisasi, Layanan.Nomenklatur HASIL OLEH UMUM, Organisasi, Nomenklatur

Dalam hal ini, permintaan akan mengembalikan hampir sama dengan permintaan ini:

PILIH Layanan.Organisasi AS Organisasi, Layanan.Nomenklatur AS Nomenklatur, Layanan.Jumlah Dokumen AS Jumlah Dokumen DARI Dokumen.

Hanya kueri pertama yang akan menciutkan rekaman dengan nomenklatur yang sama.

6. Bidang dereferensi.

Bidang referensi melalui titik disebut operasi dereferensi bidang referensi. Misalnya Pembayaran.Organisasi.Unit Administrasi. Dalam hal ini, di bidang referensi "Organisasi" dari dokumen "Pembayaran", ini merujuk ke tabel "Organisasi" lain, di mana nilai atribut "Unit Administratif" akan diterima. Penting untuk dipahami bahwa saat mengakses bidang melalui titik, platform secara implisit membuat subkueri dan menggabungkan tabel ini.

Meminta:

Dapat direpresentasikan sebagai:

PILIH Pembayaran.Tautan, Pembayaran.Organisasi, Pembayaran.Organisasi, Organisasi. AdministrativeUnit DARI Document.Payment SEBAGAI Pembayaran KIRI BERGABUNG Direktori.Organisasi SEBAGAI Perangkat Lunak Organisasi Payment.Organization = Organizations.Link

Saat dereferencing bidang referensi dari tipe komposit, kerangka kerja mencoba membuat gabungan implisit ke semua tabel yang merupakan bagian dari tipe bidang. Dalam hal ini, kueri tidak akan optimal, jika diketahui dengan jelas jenis bidang apa, perlu untuk membatasi bidang tersebut berdasarkan jenis dengan konstruksi CEPAT().

Misalnya, ada daftar akumulasi "Pembayaran yang tidak terisi", di mana beberapa dokumen dapat bertindak sebagai pencatat. Dalam hal ini, mendapatkan nilai detail registrar dengan cara ini adalah salah:

PILIH Unallocated Payments.Registrar.Date, ..... DARI Akumulation Register.Unallocated Payments AS Unallocated Payments

Anda harus membatasi jenis logger bidang komposit:

PILIH EXPRESS(Pembayaran yang Tidak Dialokasikan. Dokumen Pencatat AS. Pembayaran). Tanggal, ..... DARI Daftar Akumulasi. Pembayaran yang Tidak Dialokasikan SEBAGAI Pembayaran yang Tidak Dialokasikan

7. Konstruksi "DI MANA"

Dengan join kiri dari dua tabel, ketika Anda menerapkan kondisi "WHERE" pada tabel kanan, kita akan mendapatkan hasil yang mirip dengan hasil dengan gabungan tabel dalam.

Contoh. Penting untuk memilih semua Klien dari Direktori Klien dan untuk klien yang memiliki dokumen pembayaran dengan nilai atribut "Organisasi" = &Organisasi, tampilkan dokumen "Pembayaran", bagi yang tidak, jangan tampilkan.

Hasil kueri akan mengembalikan rekaman hanya untuk pelanggan yang memiliki pembayaran berdasarkan organisasi dalam parameter, dan akan memfilter pelanggan lain. Oleh karena itu, Anda harus terlebih dahulu mendapatkan semua pembayaran untuk organisasi "ini dan itu" di tabel sementara, lalu sambungkan ke direktori "Klien" dengan sambungan kiri.

SELECT Payment.Reference AS Payment, Payment.Shareholder AS Client PUT topayments FROM Document.Payment AS Payment WHERE Payment.Department = &Department; ////////////////////////////////////////////////// / ////////////////////////////// SELECT Clients.Referensi SEBAGAI Klien, ISNULL(topayments.Payment, "") SEBAGAI Pembayaran DARI Direktori .Klien SEBAGAI Klien KIRI BERGABUNG

Anda bisa menyiasati kondisi ini dengan cara lain. perlu untuk memaksakan kondisi "WHERE" secara langsung dalam hubungan kedua tabel. Contoh:

PILIH Clients.Reference, Payment.Reference FROM Directory.US_Subscribers AS ST_Subscribers KIRI JOIN Document.Payment AS Payment SOFTWARE (Clients.Reference = Payment.Client AND Payment.Client.Name SEPERTI "Sugar Bag") GROUP OLEH Clients.Reference, Payment. Tautan

8. Bergabung dengan Tabel Bersarang dan Virtual

Subkueri sering diperlukan untuk memilih data menurut beberapa kondisi. Jika Anda kemudian menggunakannya bersamaan dengan tabel lain, maka ini dapat sangat memperlambat eksekusi kueri.

Misalnya, kita perlu mendapatkan Jumlah Saldo untuk tanggal saat ini untuk beberapa klien.

SELECT UnallocatedPayBalances.Customer, UnallocatedPaymentsRemains.AmountBalance FROM (PILIH Clients.Reference AS Reference FROM Directory.Clients AS Clients WHERE Clients.Reference B(&Clients)) AS NestedQuery

Saat menjalankan kueri seperti itu, pengoptimal DBMS kemungkinan akan membuat kesalahan saat memilih paket, yang akan menyebabkan eksekusi kueri yang kurang optimal. Saat menggabungkan dua tabel, pengoptimal DBMS memilih algoritme untuk menggabungkan tabel berdasarkan jumlah rekaman di kedua tabel. Dalam kasus kueri bersarang, sangat sulit untuk menentukan jumlah rekaman yang akan dikembalikan oleh kueri bersarang. Oleh karena itu, alih-alih kueri bersarang, Anda harus selalu menggunakan tabel sementara. Jadi mari kita menulis ulang kueri.

PILIH Clients.Link AS Link PUT Clients FROM Directory.Clients AS Clients WHERE
Klien.Link B (&Klien) ; ////////////////////////////////////////////////// / ///////////////////// SELECT tClients.Reference, UnallocatedPaymentsBalances.SumBalance, DARI tClients SEBAGAI tClients KIRI BERGABUNG Daftar Akumulasi.UnallocatedPayments.Saldo (, Client IN (PILIH tClients.Reference FROM tClients)) SEBAGAI UnallocatedPaymentsBalances ON tClients.Reference = UnallocatedPaymentsBalances.Clients

Dalam hal ini, pengoptimal akan dapat menentukan berapa banyak rekaman yang digunakan tabel sementara tClients dan akan dapat memilih algoritme penggabungan tabel yang optimal.

Tabel Virtual , memungkinkan Anda mendapatkan data yang hampir siap pakai untuk sebagian besar tugas aplikasi (Slice of the First, Slice of the Last, Residuals, Turnovers, Residuals and Turnovers) Kata kunci di sini adalah virtual. Tabel-tabel ini tidak bersifat fisik, tetapi dirakit oleh sistem dengan cepat, mis. saat menerima data dari tabel virtual, sistem mengumpulkan data dari tabel akhir register, komposisi, grup, dan masalah kepada pengguna.

Itu. saat Anda bergabung dengan tabel virtual, Anda bergabung dengan subquery. Dalam hal ini, pengoptimal DBMS juga dapat memilih rencana gabungan yang tidak optimal. Jika kueri tidak dibentuk dengan cukup cepat dan kueri menggunakan gabungan dalam tabel virtual, disarankan untuk mentransfer akses ke tabel virtual ke tabel sementara, lalu membuat gabungan antara dua tabel sementara. Mari tulis ulang kueri sebelumnya.

PILIH Clients.Link AS Link PUT Clients FROM Directory.Clients AS Clients INDEX BY Link WHERE
Klien.Link B (&Klien) ; ////////////////////////////////////////////////// / ///////////////////////////// SELECT UnallocatedPayments.AmountBalance, UnallocatedPayments.Pelanggan SEBAGAI Pelanggan MENEMPATKAN saldo DARI Daftar Akumulasi.Pembayaran yang Tidak Dialokasikan. Balances(, Client IN (SELECT tClients.Reference FROM tClients)) SEBAGAI Saldo Pembayaran yang Tidak Dialokasikan; ////////////////////////////////////////////////// / ///////////////////////////// PILIH tClients.Reference, thenRemains.SumRemainder SEBAGAI SumRemainder DARI tClients SEBAGAI tClients tClients.Reference = tRemainders .Klien

9.Memeriksa hasil query.

Hasil eksekusi kueri mungkin kosong; untuk memeriksa nilai kosong, gunakan konstruksi:

RequestRes = Permintaan.Jalankan(); Jika reQuery.Empty() Kemudian Return; Berakhir jika;

metode Kosong() harus digunakan sebelum metode Memilih() atau Membongkar(), karena butuh waktu untuk mendapatkan koleksinya.

Ini bukan penemuan bagi siapa pun yang sangat tidak diinginkan untuk menggunakan kueri dalam satu siklus. Ini secara kritis dapat mempengaruhi waktu operasi fungsi tertentu. Sangat diinginkan untuk menerima semua data dalam permintaan dan baru kemudian memproses data dalam satu lingkaran. Namun terkadang ada kasus ketika tidak mungkin mengeluarkan permintaan dari loop. Dalam hal ini, untuk pengoptimalan, Anda dapat memindahkan pembuatan kueri di luar loop, dan mengganti parameter yang diperlukan dalam loop dan menjalankan kueri.

Permintaan = Permintaan Baru; Query.Text = "SELECT | Clients.Link, | Clients.Tanggal Lahir |DARI | Directory.Clients SEBAGAI Klien |WHERE | Clients.Link = &Klien"; Untuk Setiap Baris DARI TableClients Loop Query.SetParameter("Klien", Klien); QueryResult = Query.Execute().Select(); Akhir Siklus;

Ini akan menyelamatkan sistem dari penguraian permintaan dalam satu lingkaran.

11. Konstruksi "MEMILIKI".

Konstruksi yang cukup langka dalam kueri. Memungkinkan Anda menerapkan ketentuan pada nilai fungsi agregat (SUM, MINIMUM, AVERAGE, dll.). Misalnya, Anda hanya perlu memilih pelanggan yang jumlah pembayarannya pada bulan September lebih dari 13.000 rubel. Jika Anda menggunakan kondisi "WHERE", pertama-tama Anda harus membuat tabel sementara atau kueri bersarang, mengelompokkan catatan di sana berdasarkan jumlah pembayaran, lalu memberlakukan kondisi. Konstruksi "HAVING" akan membantu menghindari hal ini.

PILIH Pembayaran.Pelanggan, SUM(Jumlah.Pembayaran) SEBAGAI Jumlah DARI Dokumen.Pembayaran SEBAGAI Pembayaran MANA BULAN(Tanggal.Pembayaran) = 9 KELOMPOK BERDASARKAN PEMBAYARAN.Pelanggan MEMILIKI JUMLAH(Jumlah.Pembayaran) > 13000

Di konstruktor, yang perlu Anda lakukan hanyalah membuka tab "Kondisi", tambahkan kondisi baru dan centang kotak "Kustom". Lalu tulis saja Jumlah(Pembayaran.Jumlah) > 13000


12. Nilai nol

Saya tidak akan menjelaskan di sini prinsip logika tiga nilai dalam database, ada banyak artikel tentang topik ini. Sekilas saja caranya BATAL dapat memengaruhi hasil kueri. Nilai NULL sebenarnya bukan nilai, dan fakta bahwa nilai tersebut tidak ditentukan tidak diketahui. Oleh karena itu, setiap operasi pada NULL mengembalikan NULL, baik itu penambahan, pengurangan, pembagian, atau perbandingan. Nilai NULL tidak dapat dibandingkan dengan nilai NULL karena kita tidak tahu apa yang harus dibandingkan. Itu. kedua perbandingan ini: NULL = NULL, NULL<>NULL tidak Benar atau Salah, itu tidak diketahui.

Mari kita lihat sebuah contoh.

Untuk pelanggan yang tidak memiliki pembayaran, kami perlu menampilkan kolom "Atribut" dengan nilai "Tidak ada pembayaran". Dan kami tahu pasti bahwa kami memiliki klien seperti itu. Dan untuk mencerminkan esensi dari apa yang saya tulis di atas, mari kita lakukan dengan cara ini.

PILIH "Tidak ada pembayaran" AS Atribut, Dokumen NULL AS PUT ke pembayaran; ////////////////////////////////////////////////// / ////////////////////////////// SELECT Clients.Link AS Client, Payment.Link AS Payment PUT tClientPayment FROM Directory.Clients SEBAGAI Klien KIRI BERGABUNG Dokumen.Pembayaran SEBAGAI Software Pembayaran Clients.Link = Payment.Shareholder; ////////////////////////////////////////////////// / ////////////////////////////// PILIH tClientPayment.Pelanggan DARI tClientPay SEBAGAI tClientPayment INTERNAL GABUNG ke pembayaran SEBAGAI pembayaran OLEH tClientPayment.Payment = topayments.Document

Perhatikan tabel sementara kedua tCustomerPayment. Dengan join kiri, saya memilih semua klien dan semua pembayaran untuk klien ini. Untuk pelanggan yang tidak memiliki pembayaran, bidang "Pembayaran" akan menjadi NULL . Mengikuti logika, di tabel sementara pertama "topayments" saya menetapkan 2 bidang, salah satunya adalah NULL, yang kedua adalah baris "Tidak memiliki pembayaran". Di tabel ketiga, saya menggabungkan tabel "tClientPayment" dan "tPayment" dengan kolom "Payment" dan "Document" dengan gabungan dalam. Kita tahu bahwa pada tabel pertama kolom "Dokumen" adalah NULL, dan pada tabel kedua yang tidak memiliki pembayaran pada kolom "Pembayaran" juga NULL. Apa yang akan mengembalikan koneksi seperti itu kepada kita? Dan itu tidak akan mengembalikan apa pun. Karena perbandingan NULL = NULL tidak bernilai True.

Agar kueri mengembalikan hasil yang diharapkan kepada kami, kami menulis ulang:

PILIH "Tidak ada pembayaran" SEBAGAI Tanda, NILAI(Dokumen. Pembayaran. Referensi Kosong) SEBAGAI Dokumen PUT ke Pembayaran; ////////////////////////////////////////////////// / ////////////////////////////// SELECT Clients.Reference AS Client, ISNULL(Payment.Reference, VALUE(Document.Payment .EmptyReference )) CARA MENEMPATKAN tClientPayment FROM Directory.Clients AS Clients LEFT JOIN Document.Payment AS Payment ON Clients.Reference = Payment.Shareholder; ////////////////////////////////////////////////// / ////////////////////////////// PILIH tClientPayment.Pelanggan DARI tClientPay SEBAGAI tClientPayment INTERNAL GABUNG ke pembayaran SEBAGAI pembayaran OLEH tClientPayment.Payment = topayments.Document

Sekarang, di tabel sementara kedua, kami telah menunjukkan bahwa jika kolom "Pembayaran" adalah NULL, maka kolom ini = referensi kosong ke dokumen pembayaran. Di Tabel Pertama, kami juga mengganti NULL dengan referensi nol. Sekarang bidang non-NULL terlibat dalam koneksi dan kueri akan mengembalikan hasil yang diharapkan.

Semua permintaan yang terkandung dalam artikel mencerminkan situasi yang ingin saya pertimbangkan dan tidak lebih. TENTANG mereka juga tidak bisa gila atau tidak optimal, yang utama adalah mencerminkan esensi dari contoh.

13. Fitur desain tidak berdokumen "PILIHAN KAPAN...KEMUDIAN....AKHIR".

Jika diperlukan untuk mendeskripsikan konstruk "Kondisi" dalam permintaan, maka kami menggunakan sintaks standar:

PILIH PILIHAN KETIKA Users.Name = "Vasya Pupkin" LALU "Karyawan favorit kami" LAINNYA "Kami tidak tahu ini" BERAKHIR SEBAGAI Field1 DARI Directory.Users SEBAGAI Pengguna

Namun bagaimana jika, misalnya, kita perlu mendapatkan nama bulan dalam kueri? Menulis konstruksi besar dalam kueri itu jelek dan memakan waktu, sehingga bentuk notasi di atas dapat membantu kita:

PILIH BULAN(US_Consumption Calculation_Turnover Schedule.Periode Penghitungan) KETIKA 1 LALU "Januari" SAAT 2 LALU "Februari" SAAT 3 LALU "Maret" SAAT 4 LALU "April" SAAT 5 LALU "Mei" SAAT 6 LALU "Juni" SAAT 7 LALU " Juli" SAAT 8 LALU "Agustus" SAAT 9 LALU "September" SAAT 10 LALU "Oktober" SAAT 11 LALU "November" SAAT 12 LALU "Desember" BERAKHIR SEBAGAI BULAN

Kini desainnya terlihat tidak begitu rumit dan mudah dirasakan.

14. Eksekusi kueri batch.


Agar tidak menghasilkan permintaan, Anda dapat membuat satu permintaan besar, memecahnya menjadi paket dan sudah bekerja dengannya.
Misalnya, saya perlu mendapatkan dari direktori "Pengguna" bidang: "Tanggal Lahir" dan peran yang tersedia untuk setiap pengguna. untuk membongkar ke bagian tabular yang berbeda pada formulir. Tentu saja, Anda dapat melakukan ini dalam satu kueri, lalu Anda harus mengulang catatan atau menciutkan, atau Anda dapat melakukan ini:

SELECT Users.Link AS Name, Users.Tanggal Lahir, Users.Role ENTER Users FROM Directory.Users AS Users; ////////////////////////////////////////////////// / ////////////////////////////// SELECT tuUsers.Name, tuUsers.Tanggal Lahir DARI tuUsers SEBAGAI kelompok tuUsers OLEH tuUsers. Nama, tuUsers.Tanggal Lahir; ////////////////////////////////////////////////// / /////////////////////////////// SELECT wUsers.Name, wUsers.Role DARI wUsers SEBAGAI wUsers GROUP OLEH wUsers.Name, wUsers.Tanggal Lahir

tPackage = Request.ExecutePackage();

TP_BirthDate = tPackage.Unload();
TP_Roles = tPackage.Unload();

Seperti yang bisa kita lihat, kueri dapat dieksekusi dalam batch dan bekerja dengan hasilnya sebagai larik. Dalam beberapa kasus, sangat nyaman.

15. Ketentuan dalam permintaan batch

Misalnya, kami memiliki permintaan batch, di mana kami pertama kali mendapatkan bidang: "Nama, Tanggal Lahir, Kode" dari direktori "Pengguna" dan ingin mendapatkan catatan dengan kondisi bidang ini dari direktori "Individu".

SELECT Users.Individual.Name AS Name, Users.Individual.Tanggal Lahir SEBAGAI Tanggal Lahir, Users.Individual.Code AS Code PUT in Users FROM Directory.Users AS Users; ////////////////////////////////////////////////// / ////////////////////////////// SELECT Individuals.Link AS Individual FROM Directory.Individuals AS Individuals

Anda dapat menerapkan kondisi seperti ini:

DI MANA Individu.Kode Di (PILIH TueUsers.Kode DARI TuUsers) DAN Individu.Nama Di (PILIH TueUsers.Kode DARI TuUUsers) DAN Individu.Tanggal Lahir Di (PILIH TueUsers.Tanggal Lahir DARI TuUsers)

Dan itu mungkin seperti ini:

WHERE (Individuals.Code, Individuals.Name, Individuals.Tanggal Lahir) AT (SELECT TueUsers.Code, TueUsers.Name, TueUsers.Tanggal Lahir DARI TueUsers)

Dan pastikan untuk mengikuti aturan.

16. Panggil Query Builder untuk "Condition" di Batch Query

Saat Anda perlu memaksakan suatu kondisi, seperti pada contoh di atas, Anda bisa lupa bagaimana bidang ini atau itu dipanggil di tabel virtual.
Misalnya, Anda perlu menerapkan ketentuan pada bidang "Tanggal Lahir", dan dalam tabel virtual bidang ini disebut "Tanggal Lahir Debitur", dan jika Anda lupa namanya, Anda harus keluar dari pengeditan kondisi tanpa menyimpan dan melihat nama bidang. Untuk menghindarinya, Anda bisa menggunakan trik berikut.

Penting untuk meletakkan tanda kurung setelah Konstruksi "B" dan meninggalkan ruang kosong (spasi) di antara tanda kurung, pilih tempat ini dan panggil konstruktor kueri. Konstruktor akan memiliki akses ke semua tabel kueri batch. Penerimaan berfungsi baik pada tabel register virtual maupun untuk tab "Ketentuan". Dalam kasus terakhir, Anda perlu mencentang kotak "A (kondisi sewenang-wenang)" dan masuk ke mode pengeditan "F4".

Kueri sering dibuat saat dalam perjalanan dan hanya berfungsi untuk menampilkan "trik" yang telah saya pertimbangkan.

Saya ingin mempertimbangkan penggunaan indeks dalam kueri, tetapi ini adalah topik yang sangat luas. Saya akan menaruhnya di artikel terpisah, atau nanti menambahkannya di sini.

upd1. Paragraf 11,12
upd2. Butir 13,14,15,16

Buku Bekas:
1C: Bahasa permintaan perusahaan 8 - E.Yu. Khrustalev
Pengembangan profesional dalam sistem 1C:Enterprise 8.

Saat mengatur sampel dalam masalah nyata, dalam sebagian besar kasus, pemilihan data diatur sesuai dengan kriteria tertentu.

Jika pemilihan dibuat dari tabel nyata, tidak ada kesulitan yang muncul. Data diproses dengan sangat sepele:

Jika sumber dalam kueri adalah tabel virtual, situasinya menjadi lebih rumit.


Bahasa kueri memungkinkan Anda untuk menerapkan ketentuan pada pilihan dari tabel virtual dengan dua cara: di klausa WHERE dan menggunakan parameter tabel virtual. Kedua cara tersebut akan mengarah pada hasil yang sama (kecuali dalam beberapa kasus tertentu), tetapi keduanya jauh dari setara.

Kita sudah tahu bahwa tabel virtual disebut virtual karena sebenarnya tidak ada di database. Mereka dibentuk hanya pada saat permintaan diajukan kepada mereka. Meskipun demikian, akan lebih mudah bagi kami (yaitu, mereka yang membuat kueri) untuk menganggap tabel virtual persis seperti yang asli. Apa yang akan terjadi pada sistem 1C Enterprise 8 ketika kueri yang telah kita susun masih mengacu pada tabel virtual?

Pada langkah pertama, sistem akan membuat tabel virtual. Pada langkah kedua, record akan dipilih dari tabel hasil yang memenuhi kondisi yang ditentukan dalam klausa WHERE:
Terlihat jelas bahwa tidak semua record dari tabel virtual (dan, akibatnya, dari database) akan jatuh ke dalam seleksi akhir, tetapi hanya yang memenuhi kondisi yang diberikan. Dan catatan lainnya hanya akan dikeluarkan dari hasil.

Dengan demikian, sistem tidak hanya tidak berguna, tetapi juga menggandakan pekerjaan yang tidak berguna! Pertama, sumber daya akan dihabiskan untuk membuat tabel virtual berdasarkan data tambahan (pada gambar mereka ditandai sebagai "area data A dan B"), dan kemudian lebih banyak pekerjaan akan dilakukan untuk memfilter data ini dari hasil akhir.

Apakah mungkin untuk segera, pada tahap membangun tabel virtual, menolak untuk menggunakan data yang tidak perlu? Ternyata kamu bisa. Inilah gunanya pengaturan tabel virtual:

Dengan parameterisasi tabel virtual, kami segera membatasi jumlah data yang akan diproses oleh kueri.

Apa perbedaan antara nilai parameter tabel virtual "Metode Tambahkan"?
Saat ComplementMethod disetel ke "movements", hanya periode di mana ada pergerakan yang akan dikembalikan. Saat "Pergerakan DAN Batas Periode" ditetapkan, maka 2 catatan akan ditambahkan ke pergerakan di atas: pergerakan di awal dan akhir periode yang ditentukan dalam parameter BT. Kolom "Registrar" akan kosong untuk 2 record ini.

Informasi diambil dari situs

Register akumulasi dalam 1C: Sistem perusahaan dibagi menjadi dua jenis: register akumulasi sisa dan register akumulasi revolusi.

Jenis register dipilih saat membuatnya di konfigurator

Sesuai namanya, beberapa dirancang untuk menerima saldo pada tanggal tertentu, dan yang kedua menerima omset untuk periode yang dipilih. Bergantung pada jenis register akumulasi, platform 1C:Enterprise menghasilkan kumpulan tabel virtual yang berbeda. Pada artikel ini, kami akan mempertimbangkan bekerja dengan tabel virtual register akumulasi. Untuk melakukan ini, kami akan membuat daftar akumulasi saldo - Barang Tetap dan daftar akumulasi omset - Perputaran Barang.

Sekarang mari kita lihat tabel virtual apa yang disediakan platform untuk masing-masing register ini.

Daftar omzet

Untuk kejelasan, mari buka dan lihat tabel mana yang tersedia untuk register Perputaran Barang. Ini adalah tabel register itu sendiri − Perputaran Barang, yang ada secara fisik di database, dan satu tabel virtual - Perputaran Barang Perputaran

Semuanya jelas dengan tabel standar. Mari kita lihat lebih dekat realitas virtual.

Perputaran Tabel Virtual

Tabel ini memungkinkan Anda untuk mendapatkan omset sumber daya dalam konteks pengukuran. Dalam kasus kami, kami memiliki dua dimensi: Saham Dan Produk. Dan satu sumber daya Kuantitas

Biarkan register kami memiliki entri berikut

Mari kembali ke pembuat kueri dan mulai dengan memilih dari tabel Perputaran Barang Perputaran semua bidang

Dengan demikian, permintaan akan terlihat seperti ini:

PILIH Perputaran Barang Perputaran. Gudang, Perputaran Barang Perputaran.Produk, Perputaran Barang Perputaran Barang. Jumlah Perputaran DARI RegisterAkumulasi. Perputaran Barang. Perputaran(,) AS Perputaran Barang Perputaran Barang

Hasil kueri terlihat seperti ini:

Artinya, kami menerima omset dalam konteks barang dan gudang sepanjang waktu. Misalkan kita tidak tertarik dengan gudang dan ingin mendapatkan omzet hanya dalam konteks barang.

Untuk melakukannya, kecualikan dimensi dari kueri Saham

PILIH PerputaranBarangPerputaran.Produk,PerputaranBarangPerputaran.JumlahPerputaran DARI DaftarAkumulasi.PerputaranBarang.Perputaran(,) SEPERTI Perputaran BarangPerputaran

dan sebagai hasilnya kita hanya akan memiliki dua baris

Tetapi sebagai aturan, tidak diharuskan menerima turnover selama keberadaan register. Pada dasarnya, mereka dibutuhkan untuk periode tertentu: bulan, kuartal, tahun, dll. Plus, Anda biasanya membutuhkan pilihan berdasarkan dimensi (Produk, Gudang). Ini dicapai dengan menggunakan parameter tabel virtual. Akan lebih mudah untuk mengisi parameter dari konstruktor. Dengan tombol Opsi Tabel Virtual kotak dialog terbuka di mana Anda dapat mendaftarkan semua yang kami butuhkan:

Setelah itu, kueri asli kami akan mengambil bentuk berikut

PILIH Perputaran Barang Perputaran.Gudang, Perputaran Barang Perputaran.Produk, Perputaran Barang Perputaran.Jumlah Perputaran Dari Daftar Akumulasi.Perputaran Barang.Perputaran(&Awal Periode, &Akhir Periode, Gudang = &Gudang) SEBAGAI Perputaran Barang Perputaran

Seperti yang Anda lihat, perbedaannya adalah parameter muncul dalam tanda kurung setelah nama tabel virtual, yang harus diisi sebelum menjalankan kueri.

Bagi mereka yang baru mulai bekerja dengan tabel virtual, seringkali tergoda untuk menyetel pemilihan dengan cara biasa daripada menggunakan parameter:

DARI Daftar Akumulasi.PerputaranBarang.Perputaran(,) SEBAGAI PerputaranBarangPerputaranDimanaPerputaranBarangPerputaran.Gudang = &Gudang

Saat mengisi parameter, kami melewatkannya Periodisitas. Mari buka daftar dan pilih dari banyak opsi yang memungkinkan Bulan. Kami akan menghapus semua parameter lainnya agar tidak bingung.

Setelah itu, kami mengamati bahwa bidang muncul di bidang tabel Periode.

Menambahkannya ke bidang yang dipilih, kami mendapatkan teks kueri berikut:

PILIH Perputaran Barang Perputaran.Periode, Perputaran Barang Perputaran.Gudang, Perputaran Barang Perputaran.Produk, Perputaran Barang Perputaran.Jumlah Perputaran Dari Daftar Akumulasi. Perputaran Barang. Perputaran (, Bulan,) SEBAGAI Perputaran Barang Perputaran

Kami menjalankan permintaan:

Dengan demikian, dalam interval waktu yang dipilih, kita dapat memecah pergantian menjadi interval yang lebih kecil sesuai dengan frekuensi yang dipilih.

Daftar akumulasi saldo

Sama seperti dengan register balik, mari kita lihat di pembuat kueri tabel virtual mana yang tersedia untuk register akumulasi saldo

Seperti yang Anda lihat, tiga tabel virtual tersedia untuk daftar akumulasi saldo: Perputaran, Tetap, Sisa dan Perputaran. Mari pertimbangkan masing-masing secara terpisah.

Perputaran Tabel Virtual

Meskipun jenis registernya adalah Tetap, kita masih bisa mendapatkan omzet darinya. Selain itu, kami memiliki dua sumber daya tambahan di sini: Yang akan datang Dan Konsumsi

Izinkan saya mengingatkan Anda bahwa ketika entri dibuat dalam daftar saldo, jenis pergerakan akumulasi (pendapatan atau pengeluaran) ditunjukkan, sedangkan untuk daftar omset, jenis pergerakan tidak ditunjukkan. Oleh karena itu, di sini kami memiliki bonus tambahan berupa kesempatan untuk menerima tidak hanya omset untuk periode tersebut secara keseluruhan, tetapi juga pendapatan dengan pengeluaran secara terpisah. Namun tentunya jika ada register omset di metadata dengan himpunan pengukuran yang serupa, maka lebih baik menggunakannya untuk mendapatkan omzet. Secara umum, bekerja dengan tabel virtual ini mirip dengan bekerja dengan tabel virtual Perputaran daftar omset yang dibahas di atas.

Saldo Tabel Virtual

Tabel ini digunakan untuk mendapatkan sumber daya yang tersisa dalam hal dimensi. Dalam parameter tabel, kami dapat menentukan tanggal kami menerima saldo dan menyetel filter:

Mari kita pertimbangkan contoh kecil. Kami memiliki entri register berikut:

Kami memilih semua bidang yang tersedia dan menetapkan akhir Juni sebagai tanggal penerimaan saldo. Kami tidak akan menetapkan seleksi berdasarkan pengukuran. Maka teks permintaan akan terlihat seperti ini:

PILIH GoodsRemainsRemains.Warehouse, GoodsRemainsRemains.Product, GoodsRemainsRemains.QuantityBalance FROM Accumulation Register.ProductsRemains.Remains(&RemainsDate,) SEBAGAI GoodsRemainsRemains

Dan setelah mengeksekusinya, kita mendapatkan hasil sebagai berikut

Meja maya

Tabel ini menggabungkan dua hal yang telah dibahas sebelumnya dan memungkinkan Anda mendapatkan omset untuk periode waktu yang dipilih, serta saldo di awal dan akhir periode. Anda juga dapat mengatur pilihan.

Penggunaan tabel ini dapat dibenarkan bila diperlukan untuk secara bersamaan memperoleh perputaran dan saldo pada awal dan akhir periode dalam satu laporan. Dalam kasus lain, penggunaannya tidak boleh disalahgunakan.



Memuat...
Atas