स्कैला के साथ कौन सा ओआरएम अच्छा काम करता है?

Question

मैं एक स्कैला कमांड लाइन एप्लिकेशन लिखने वाला हूं जो MySQL डेटाबेस पर निर्भर करता है। मैं ओआरएम के लिए चारों ओर देख रहा हूं, और मुझे ऐसा खोजने में परेशानी हो रही है जो अच्छी तरह से काम करेगी।

Lift ORM अच्छा लग रहा है, लेकिन मुझे यकीन नहीं है कि इसे पूरे लिफ्ट वेब ढांचे से हटाया जा सकता है। ActiveObjects भी ठीक दिखता है, लेकिन लेखक कहते हैं कि यह स्कैला के साथ अच्छी तरह से काम नहीं कर सकता है।

मैं जावा से स्कैला नहीं आ रहा हूं, इसलिए मुझे सभी विकल्पों को नहीं पता है। क्या किसी ने स्कैला के साथ ओआरएम का उपयोग किया है, और यदि हां, तो आपने क्या उपयोग किया और यह कितनी अच्छी तरह से काम किया?

Answer 1

कई कारण जेपीए उन्मुख चौखटे (हाइबरनेट कर रहे हैं, उदाहरण के लिए) मुहावरेदार स्काला अनुप्रयोगों सुंदर ढंग से में फिट नहीं है:

में कहा गया है के रूप में

• कोई नेस्टेड एनोटेशन रहे Scala 2.8 Preview - मतलब है कि आप मानचित्रण मेटाडाटा के रूप में व्याख्या का उपयोग नहीं कर सकते जटिल अनुप्रयोगों के लिए (यहां तक ​​कि सबसे सरल लोग अक्सर @JoinTable ->@JoinColumn) का उपयोग करते हैं;
• स्कैला और जावा संग्रह के बीच असंगतता डेवलपर्स संग्रह को परिवर्तित करते हैं; ऐसे मामले भी हैं जब अंतर्निहित ढांचे (हाइबरनेट के PersistentCollections, उदाहरण के लिए) के जटिल इंटरफेस को लागू किए बिना स्केल संग्रह को एसोसिएशन में मानचित्र करना असंभव है;
• डोमेन मॉडल सत्यापन जैसे कुछ बहुत ही सामान्य विशेषताएं, लगातार कक्षाओं पर जावाबीन सम्मेलनों की आवश्यकता होती है - ये सामान चीजों को करने का काफी "स्केल तरीका" नहीं है;
• बेशक, इंटरऑप समस्याएं (जैसे कच्चे प्रकार या प्रॉक्सी) उन मुद्दों के एक नए स्तर को पेश करती हैं जिन्हें आसानी से नहीं चलाया जा सकता है।

मुझे और भी कारण हैं, मुझे यकीन है। यही कारण है कि हमने Circumflex ORM project शुरू किया है। यह शुद्ध-स्काला ओआरएम क्लासिक जावा ओआरएम के दुःस्वप्न को खत्म करने के लिए सबसे अच्छा प्रयास करता है। क्लासिक जेपीए POJOs से

class User extends Record[User] { 
    val name = "name".TEXT.NOT_NULL 
    val admin = "admin".BOOLEAN.NOT_NULL.DEFAULT('false') 
} 

object User extends Table[User] { 
    def byName(n: String): Seq[User] = criteria.add(this.name LIKE n).list 
} 

// example with foreign keys: 
class Account extends Record[Account] { 
    val accountNumber = "acc_number".BIGINT.NOT_NULL 
    val user = "user_id".REFERENCES(User).ON_DELETE(CASCADE) 
    val amount = "amount".NUMERIC(10,2).NOT_NULL 
} 

object Account extends Table[Account] 

आप देख सकते हैं, इन घोषणाओं में थोड़ा और अधिक वर्बोज़ कर रहे हैं,: विशेष रूप से, आप काफी तरीके से अपने संस्थाओं को परिभाषित आप क्लासिक DDL बयान के साथ ऐसा होता है।लेकिन वास्तव में वहाँ कई अवधारणाओं कि एक साथ इकट्ठा कर रहे हैं:

• स्कीमा पैदा (आप आसानी से अनुक्रमित, विदेशी कुंजी और एक ही डीएसएल की तरह फैशन में अन्य सामग्री जोड़ सकते हैं) के लिए सटीक DDL;
• सभी प्रश्नों को डीएओ में बिखरे हुए होने के बजाय "टेबल ऑब्जेक्ट" के अंदर इकट्ठा किया जा सकता है; प्रश्न खुद बहुत लचीला हैं, आप चर वस्तुओं में क्वेरी ऑब्जेक्ट्स, भविष्यवाणी, अनुमान, सबक्वायरी और रिलेशनशिप एलियास स्टोर कर सकते हैं ताकि आप उनका पुन: उपयोग कर सकें, और यहां तक ​​कि मौजूदा प्रश्नों से बैच अपडेट ऑपरेशंस भी बना सकते हैं (उदाहरण के लिए सम्मिलित करें);
• एसोसिएशन के बीच पारदर्शी नेविगेशन (एक-से-एक, कई से एक, एक से कई और कई से कई माध्यमिक संबंध) आलसी या उत्सुक fetching रणनीतियों द्वारा हासिल किया जा सकता है; दोनों मामलों में संघों को अंतर्निहित संबंधों की विदेशी कुंजी के शीर्ष पर स्थापित किया जाता है;
• सत्यापन ढांचे का हिस्सा है;
• एक मेवेन 2 प्लगइन भी है जो स्कीमा उत्पन्न करने और त्वरित XML आयातित फ़ाइलों से प्रारंभिक डेटा आयात करने की अनुमति देता है।

केवल बातें स्वरित ORM का अभाव हैं:

• बहु-स्तंभ प्राथमिक कुंजी (हालांकि यह बहु-स्तंभ विदेशी बहु-स्तंभ अद्वितीय की कमी के द्वारा समर्थित कुंजी बनाने के लिए संभव है, लेकिन यह केवल के लिए है डेटा अखंडता);
• पूर्ण दस्तावेज (हालांकि हम सक्रिय रूप से इस पर काम कर रहे हैं);
• दस अरब डॉलर के उत्पादन प्रणालियों की सफलता की कहानियां जिनमें सर्कफ्लेक्स ओआरएम की मूल तकनीक है।

पीएस मुझे आशा है कि इस पोस्ट को विज्ञापन नहीं माना जाएगा। ऐसा नहीं है, वास्तव में - मैं जितना संभव हो उतना उद्देश्य बनने की कोशिश कर रहा था।

Answer 2

मैंने EclipseLink JPA के साथ प्रयोग किया और बुनियादी परिचालन मेरे लिए ठीक काम किया। जेपीए एक जावा मानक है और अन्य कार्यान्वयन भी हैं जो काम कर सकते हैं (OpenJPA, आदि)।

import javax.persistence.Entity; 
import javax.persistence.GeneratedValue; 
import javax.persistence.Id; 

@Entity { val name = "Users" } 
class User { 
    @Id 
    @GeneratedValue 
    var userid:Long = _ 

    var login:String = _ 

    var password:String = _ 

    var firstName:String = _ 

    var lastName:String = _ 
} 

Answer 3

यहाँ है मूल रूप से @Column एनोटेशन के साथ एक ही उदाहरण:: यहाँ क्या स्काला में एक जेपीए वर्ग की तरह दिखता है का एक उदाहरण है

/* 
    Corresponding table: 

CREATE TABLE `users` (
    `id` int(11) NOT NULL auto_increment, 
    `name` varchar(255) default NULL, 
    `admin` tinyint(1) default '0', 
    PRIMARY KEY (`id`) 
) 

*/ 

import _root_.javax.persistence._ 

@Entity 
@Table{val name="users"} 
class User { 

    @Id 
    @Column{val name="id"} 
    var id: Long = _ 

    @Column{val name="name"} 
    var name: String = _ 

    @Column{val name="admin"} 
    var isAdmin: Boolean = _ 

    override def toString = "UserId: " + id + " isAdmin: " + isAdmin + " Name: " + name 

} 

Answer 4

मुझे स्कैला के लिए एक नई ओआरएम लाइब्रेरी की पहली रिलीज की घोषणा करने में खुशी हुई। MapperDao डोमेन टेबल डेटाबेस डेटाबेस में नक्शा। यह वर्तमान में mysql का समर्थन करता है, postgresql (ऑरैकल ड्राइवर जल्द ही उपलब्ध होगा), एक-से-एक, कई से एक, एक से कई, कई से अधिक रिश्तों, स्वत: उत्पन्न कुंजी, लेनदेन और वैकल्पिक रूप से वसंत के साथ अच्छी तरह से एकीकृत करता है ढांचा। यह डोमेन कक्षाओं के डिजाइन पर स्वतंत्रता की अनुमति देता है जो दृढ़ता से प्रभावित नहीं होते हैं, अपरिवर्तनीयता को प्रोत्साहित करते हैं और सुरक्षित हैं। लाइब्रेरी प्रतिबिंब पर आधारित नहीं है बल्कि अच्छे स्कैला डिजाइन सिद्धांतों पर आधारित है और डेटा पूछने के लिए एक डीएसएल है, जो चुनिंदा प्रश्नों के करीब मिलती है। इसे बराबर() या हैशकोड() विधियों के कार्यान्वयन की आवश्यकता नहीं है जो स्थायी संस्थाओं के लिए समस्याग्रस्त हो सकते हैं। मैपिंग प्रकार सुरक्षित स्कैला कोड का उपयोग करके किया जाता है।

विवरण और उपयोग निर्देशों mapperdao की साइट पर पाया जा सकता:

http://code.google.com/p/mapperdao/

पुस्तकालय ऊपर साइट पर डाउनलोड के लिए उपलब्ध है और यह भी एक Maven निर्भरता (प्रलेखन कि यह कैसे उपयोग करने के लिए पर विवरण शामिल हैं के रूप में Maven के माध्यम से)

उदाहरण में पाया जा सकता:

https://code.google.com/p/mapperdao-examples/

कोड नमूना के माध्यम से पुस्तकालय के 10

बहुत संक्षिप्त परिचय:

class Product(val name: String, val attributes: Set[Attribute]) 
class Attribute(val name: String, val value: String) 
... 

val product = new Product("blue jean", Set(new Attribute("colour", "blue"), new Attribute("size", "medium"))) 
val inserted = mapperDao.insert(ProductEntity, product) 
// the persisted entity has an id property: 
println("%d : %s".format(inserted.id,inserted)) 

क्वैरी बहुत परिचित है:

val o=OrderEntity 

import Query._ 
val orders = query(select from o where o.totalAmount >= 20.0 and o.totalAmount <= 30.0) 
println(orders) // a list of orders 

मैं पुस्तकालय का उपयोग करें और प्रतिक्रिया देने के लिए हर किसी के लिए प्रोत्साहित करते हैं। दस्तावेज सेटअप और उपयोग निर्देशों के साथ वर्तमान में काफी व्यापक है। कृपया googlemail dot com पर kostas dot kougios पर टिप्पणी करने के लिए स्वतंत्र महसूस करें और मेरे साथ संपर्क करें।

धन्यवाद,

Kostantinos Kougios

Answer 5

Slick एक कार्यात्मक दुनिया के लिए एक आदर्श मुकाबला नहीं है। पारंपरिक ओआरएम स्कैला के लिए एकदम सही फिट नहीं है। Slick अच्छी तरह से composes और एक डीएसएल का उपयोग करता है जो स्कैला संग्रह कक्षाओं और समझ के लिए नकल करता है।

Answer 6

बेशक, किसी भी जावा डेटाबेस एक्सेस फ्रेमवर्क स्कैला में भी काम करेगा, सामान्य संग्रह जो आप सामना कर सकते हैं, जैसे संग्रह रूपांतरण आदि। उदाहरण के लिए jOOQ, स्कैला में अच्छी तरह से काम करने के लिए मनाया गया है। स्काला में jOOQ कोड का एक उदाहरण के मैनुअल में दिया जाता है:

object Test { 
    def main(args: Array[String]): Unit = { 
    val c = DriverManager.getConnection("jdbc:h2:~/test", "sa", ""); 
    val f = new Factory(c, SQLDialect.H2); 
    val x = T_AUTHOR as "x" 

    for (r <- f 
     select (
      T_BOOK.ID * T_BOOK.AUTHOR_ID, 
      T_BOOK.ID + T_BOOK.AUTHOR_ID * 3 + 4, 
      T_BOOK.TITLE || " abc" || " xy" 
     ) 
     from T_BOOK 
     leftOuterJoin (
      f select (x.ID, x.YEAR_OF_BIRTH) 
      from x 
      limit 1 
      asTable x.getName() 
     ) 
     on T_BOOK.AUTHOR_ID === x.ID 
     where (T_BOOK.ID <> 2) 
     or (T_BOOK.TITLE in ("O Alquimista", "Brida")) 
     fetch 
    ) { 
     println(r) 
    } 
    } 
} 

से http://www.jooq.org/doc/2.6/manual/getting-started/jooq-and-scala/