diff --git a/docs/04.guides/04.cookbooks/06.cached-within-request/page.md b/docs/04.guides/04.cookbooks/06.cached-within-request/page.md deleted file mode 100644 index dff60d7a1..000000000 --- a/docs/04.guides/04.cookbooks/06.cached-within-request/page.md +++ /dev/null @@ -1,35 +0,0 @@ ---- -title: Cache a query for the current request -id: cookbook-cached-within-request -related: -- tag-query -categories: -- cache -- query -description: Cache a Query for the current request -menuTitle: Query Caching ---- - -## Cache a Query for the current request ## - -Perhaps you're familiar with the "cachedwithin" attribute of the tag [[tag-query]], which is normally used as follows: - -```coldfusion - - select * from whatever where whatsoever='#whatsoever#' - -``` - -This caches the query result for ALL users for one second. This is sometimes used to cache a query for the current request, because usually most requests are completed in less than a second. - -The problem is that this cache applies to all requests and that's more complicated for Lucee, meaning unnecessary overhead on the system. - -Request query caching is a simple solution to this problem, replace the timespan defined in the "cachedWithin" attribute with the value "request": - -```coldfusion - - select * from whatever where whatsoever='#whatsoever#' - -``` - -Then the query is cached for only for the current request, independent of how long the request takes! diff --git a/docs/04.guides/04.cookbooks/28.StaticScope/page.md b/docs/04.guides/04.cookbooks/28.StaticScope/page.md deleted file mode 100644 index a5943874b..000000000 --- a/docs/04.guides/04.cookbooks/28.StaticScope/page.md +++ /dev/null @@ -1,226 +0,0 @@ ---- -title: Static scope in components -id: static_scope -categories: -- component -- scopes -- static -description: Static scope in components is needed to create an instance of cfc and call its method ---- - -## Static scope in components ## - -Static scope in components is needed to create an instance of cfc and call its method. It is used to avoid creating an instance each time you use the cfc. - -You can create an object in the Application init() function, and make it at application scope, so you can directly call the methods. - -We explain this methodology with a simple example below: - -### Example: ### - -```luceescript -// index.cfm -directory sort="name" action="list" directory=getDirectoryFromPath(getCurrentTemplatePath()) filter="example*.cfm" name="dir"; -loop query=dir { - echo('#dir.name#
'); -} -``` - -1) Create a constructor of the component. It is the instance of the current path and also create new function hey(). - -```luceescript -// Example0.cfc - Component { - public function init() { - dump("create an instance of "&listLast(getCurrentTemplatePath(),'\/')); - } - public function hey() { - dump("Salve!"); - } - } -``` - -2) Next, we instantiate the component four times, and then call the hey() function. Run this example00.cfm page in the browser. It shows five dumps. Four dumps coming from inside of the constructor and the fifth dump is from hey(). Note that the init() function is private, so you cannot load it from outside the component. Therefore, you have no access to the message within init() from the cfscript in the example below. - -```luceescript -// example0.cfm - new Example0(); - new Example0(); - new Example0(); - cfc=new Example0(); - cfc.hey(); -``` - -### Example 1: ### - -As our code gets more complicated, we need to make some additions to it. - -* One option is to create the Component in the application scope or server scope, or to use the function GetComponentMetaData to store components in a more persistent way. -* However, using the static scope is a much better option which offers more control in how you load and how you share the data between components of the specific type. This is explained in Example1 below. - -1) This code has a new static function getInstance(). This function is not a part of the instance in Component. It is static of the specific component, but not created in any instance. - -```luceescript -// Example1.cfc -Component { - public static function getInstance() { - if(isNull(static.instance)) { - static.instance=new Example1(); - } - return static.instance; - } - private function init() { - dump("create an instance of "&listLast(getCurrentTemplatePath(),'\/')); - } - public function hey() { - dump("Salve!"); - } -} -``` - -2) This example calls the getInstance() static function four times, and calls the hey() function once. - -* Next, we run this in the browser to see that the constructor calls only one instance, and function hey() is called once. It always gets the same instance because only one exists at this time. -* We give an additional request to the same page again. No constructor is displayed. Only the hey() function contents are shown. Therefore, we know that the constructor is only showing the first request of the page. - -```luceescript -// example01.cfm - Example1::getInstance(); - Example1::getInstance(); - Example1::getInstance(); - cfc=Example1::getInstance(); - cfc.hey(); -``` - -### Example 2: ### - -1) Example2 shows the same concepts that were shown in the previous Example1, but here we pass two instances for arguments. One instance for every combination of arguments passed in firstname, lastname. Then we also call the hey() function. - -```luceescript -// Example2.cfc -Component { - public static function getInstance(required string lastname, required string firstname) { - var id=hash(lastname&":"&firstname,"quick"); - if(isNull(static.instance[id])) { - static.instance[id]=new Example2(lastname,firstname); - } - return static.instance[id]; - } - private function init(required string lastname, required string firstname) { - dump("create an instance of "&listLast(getCurrentTemplatePath(),'\/')&" for "&lastname&" "&firstname); - variables.lastname=arguments.lastname; - variables.firstname=arguments.firstname; - } - public function hey() { - dump("Salve #variables.firstname#!"); - } -} -``` - -2) Next we call the getInstance() static function five times. Here we pass three different arguments into the getInstance() function. So three instances are displayed when we run this in the browser. This indicates that the same arguments are executed only once. - -```luceescript -// example02.cfm - Example2::getInstance("Quintana","Jesus"); - Example2::getInstance("Sobchak","Walter"); - Example2::getInstance("Sobchak","Walter"); - Example2::getInstance("Sobchak","Walter"); - Example2::getInstance("Sobchak","Walter").hey(); -``` - -### Example 3: ### - -1)This example is to show the difference between the body of the instance constructor and the static constructor. - -* The static constructor constructs the whole execution when the component is loaded in the memory for first time only. It does not create the same (duplicate) instance again for the execution. -* A new instance is created for every execution of an instance constructor. - -```luceescript -// Example3.cfc -Component { - //instance constructor body - dump("this is executed every time a new instance is created"); - - //static constructor body - static { - dump("this is executed only if the component is loaded for the first time"); - } -} -``` - -2) Here we call the Example3() function twice. The first request will display three instances when run in the browser. The static constructor body will execute one time, and the instance constructor body will execute two times. - -```luceescript -// example03.cfm - new Example3(); - new Example3(); -``` - -### Example 4: ### - -1) This example shows the count of how many instances of the component get loaded. In this example we define the body of the static constructor as zero, then increase the count. The instance of the component can always access the static scope because that allows you to share data between multiple instances of the component. - -```luceescript -// Example4.cfc -Component { - static { - static.counter = 0 ; - } - static.counter++; - - dump(static.counter&" instances used so far"); -} -``` - -2) Here we call the Example4() function five times. Each time the function is called, the count of counter in the static scope increases. - -```luceescript -// example04.cfm - new Example4(); - new Example4(); - new Example4(); - new Example4(); - new Example4(); -``` - -### Example 5: ### - -1) We can also use the static scope to store constant data like HOST,PORT. - -* If we store the instance in the variable scope, you will run into problems when you have a thousand components or it gets loaded a thousand times. This is a waste of time and memory storage. -* The Static scope means that a variable example only exist once and is independent of how many instances you have. So it is more memory efficient to do it that way. You can also do the same for functions. - -```luceescript -// Example5.cfc -Component { - static{ - static.HOST="lucee.org"; - static.PORT=8080; - } - public static function splitFullName(required string fullName) { - var arr=listToArray(fullName," "); - return {'lastname':arr[1],'firstname':arr[2]}; - } - public function init(required string fullname) { - variables.fullname=static.splitFullName(fullName); - } - public string function getLastName() { - return variables.fullname.lastname; - } -} -``` - -2) Here we call the Example5() function in two ways. It has a function splitFullName() that does not need to access anything (read or write data from the disks) and a variable scope that doesn't have to be part of the instance. It returns the firstname and lastname. - -```luceescript -// example05.cfm - person=new Example5("Sobchak Walter"); - dump(person.getLastName()); - dump(Example5::splitFullName("Quintana Jesus")); -``` - -### Footnotes ### - -[Lucee 5 features reviewed: static](https://dev.lucee.org/t/lucee-5-features-reviewed-static/433) - -[Video: Lucee Static Scopes in Component Code](https://www.youtube.com/watch?v=B5ILIAbXBzo&feature=youtu.be) diff --git a/docs/04.guides/04.cookbooks/29.Threads-Scope/page.md b/docs/04.guides/04.cookbooks/29.Threads-Scope/page.md deleted file mode 100644 index c97495ac6..000000000 --- a/docs/04.guides/04.cookbooks/29.Threads-Scope/page.md +++ /dev/null @@ -1,266 +0,0 @@ ---- -title: Threads -id: thread_usage -categories: -- scopes -- thread -description: How to use threads in Lucee ---- - -## Thread Scope ## - -This document explains how to use threads in Lucee. Threads are mainly used for executing code in parallel. - -### Example 1 ### - -The below example shows normal execution, waiting for all code to resolve. Here it takes 1000 milliseconds to complete the execution. - -```lucee - -function napASecond() localmode=true { - sleep(1000); -} -start=getTickCount(); -napASecond(); -dump("done in #getTickCount()-start#ms"); - -``` - -The below example shows thread execution. Code within the thread tag runs in parallel with the execution of the other code in the cfscript. Here execution does not wait for sleep. - -```lucee - -function napASecond() localmode=true { - thread { - sleep(1000); - } -} -start=getTickCount(); -napASecond(); -dump("done in #getTickCount()-start#ms"); - -``` - -Threads run independently of other threads or code in Lucee. Lucee does not the thread first and then the following code. - -Threads are mainly used to retrieve data from the database, cfhttp, or webservice. Threads are used when it does not matter how much time it takes to execute. - -### Example 2 ### - -Here we see an example using multiple threads in Lucee. All threads run in parallel. - -```lucee - -function napASecond(index) localmode=true { - thread { - thread.start=now(); - sleep(1000) - thread.end=now(); - } -} - -start=getTickCount(); -loop from=1 to=5 index="index" { - napASecond(index); -} - -// show threads -dump(var:cfthread,expand:false); -// wait for all threads to finish -thread action="join" name=cfthread.keyList(); -// show threads -dump(var:cfthread,expand:false); - -dump("done in #getTickCount()-start#ms"); - -``` - -The above example shows five threads running in parallel. The thread action= "join" line waits for all threads to finish ```cfthread``` returns struct info of all thread status. - -Same example within tag - -```lucee - - - - - - - - - - - - - - - - - - - - - - - - - - -``` - -Here the code joins three threads "t1,t2,t3". We can join threads by name. - -### Example 3 ### - -Example 3 shows threads running in parallel using the each function. - -```lucee - -tasks = ["Susi","Sorglos"]; -start=getTickCount(); -tasks.each( - function(value, index, array){ - systemOutput(value,true); - sleep(1000); - } - ,true -); -dump("done in #getTickCount()-start#ms"); - -``` - -The ```each``` function has an optional attribute called parallel. When we set the parallel attribute as true, it runs each element in parallel. By default, this attribute is false. - -Since the two array elements run in parallel, this code executes in 1 second. - -```lucee - -tasks = []; -loop from=1 to=100 index="i" { - arrayAppend(tasks,"t"&i) -} -start=getTickCount(); -tasks.each( - function(value, index, array){ - systemOutput(value,true); - sleep(1000); - } - ,true - //,100 -); -dump("done in #getTickCount()-start#ms"); - -``` - -Here we have 100 array elements. Setting the optional attribute parallel as true, it executes in 5 seconds - not in 1 second - because by default, Lucee runs 20 threads at a time and after that, it waits for free threads. So, it takes 5 seconds to complete. - -But we have the option to set the maximum threads open at a time. If it set to 100, Lucee can open 100 threads at a time to run in parallel. Then this code only takes 1 second to complete. - -The ```each``` function is not only used for an array. It can also be used for struct and query. The below example explains each type. - -```lucee - -// ARRAY -tasks = ["a","b"]; -tasks.each( - function(value, key, struct){ - systemOutput(arguments,true); - } - ,true -); -arrayEach( - tasks - ,function(value, key, struct){ - systemOutput(arguments,true); - } - ,true -); -// STRUCT -tasks = {a:1,b:2}; -structEach( - tasks - ,function(value, key, struct){ - systemOutput(arguments,true); - } - ,true -); -tasks.each( - function(value, key, struct){ - systemOutput(arguments,true); - } - ,true -); -// QUERY -persons = query( - 'firstName':['Susi','Harry'] - ,'lastName':['Sorglos','Hirsch'] -); -queryEach( - persons - ,function(value, row, query){ - systemOutput(arguments,true); - } - ,true -); -persons.each( - function(value, row, query){ - systemOutput(arguments,true); - } - ,true -); -dump("done"); - -``` - -### Example 4 ### - -Lucee members often discuss how to extend functionality to make Lucee easier to use or adding other new functionality. - -This example shows a future implementation of threads in Lucee. - -```lucee - -// Thread Pool -tasks.each( - function(value, key, struct){ - systemOutput(arguments,true); - } - ,true - ,20 // ATM default for max threads is 20, instead we plan to use a smart thread pool in the future (Java ExecutorService) -); - -``` - -Currently, the default max threads is 20. In the future, we plan to use a smart thread pool based on your JVM(Java ExecutorService). So you will not have to take care how many threads are being used. The system will do that, and provide the best choice for your code. - -```lucee - -thread /* action="thread" name="whatever" */ { - sleep(); -} - -``` - -In the future we will make threads smarter by also using a pool for threads. - -This feature is something we are planning. Changes will be implemented on the backend so that nothing changes on the front end. - -```lucee - -// Extend parallel -loop from=1 to=10 index="i" parallel=true { - ... -} -// ??? -for(i=0;i<10;i++;true) { -} - -``` - -Another planned enhancement is to extend parallel to the loop by simply adding ```parallel=true``` . It will execute the body of the loop in parallel. - -### Footnotes ### - -Here you can see above details in video - -[Lucee Threads](https://www.youtube.com/watch?v=oGUZRrcg9KE) diff --git a/docs/04.guides/04.cookbooks/42.Query_returntype/page.md b/docs/04.guides/04.cookbooks/42.Query_returntype/page.md deleted file mode 100644 index 9e946349a..000000000 --- a/docs/04.guides/04.cookbooks/42.Query_returntype/page.md +++ /dev/null @@ -1,96 +0,0 @@ ---- -title: Query return type -id: query_return_type -categories: -- query -description: This document explains the different return types for a query with some examples. ---- - -## Query return type ## - -This document explains the different return types for a query with some examples. - -### Example 1: query ### - -First we start with the regular return type for a query. This query simply returns a result set. - -```luceescript -// index.cfm -directory sort="name" action="list" directory=getDirectoryFromPath(getCurrentTemplatePath()) filter="example*.cfm" name="dir"; -loop query=dir { - echo('#dir.name#
'); -} -``` - -```luceescript -query name="qry" datasource="test" { - echo(" - select lastname,firstname from person - "); -} -dump(qry); -``` - -In this example we have a select statement with two columns in the ``person`` table. Execute the query in the browser and we get a simple result. - -### Example 2: Array ### - -Lucee can define the return type in a query tag. If we set array as follows: ``returntype="array"``. We will get the result as an array. - -```luceescript -query name="arr" datasource="test" returntype="array" { - echo(" - select lastname,firstname from person - "); -} -dump(arr); -``` - -In this array, for each row there is an item in the array and it has a struct with all the columns. So this array is special because it returns an array of struct, and it has meta information about the SQL statement. So it shows the record count and execution time of the query. - -### Example 3: struct ### - -This example shows the same concepts that were shown in the previous Example2, however instead of an array, we can do a struct. If you want to have a struct result, set the return type as struct. - -```luceescript -query name="sct" datasource="test" returntype="struct" columnKey="lastname" { - echo(" - select lastname,firstname from person - "); -} -dump(sct); -``` - -1) In this case you have to define which column is the key of the struct. Here I simply use the last name as the key of struct. - -2) Execute it in the browser, and we get struct as a result and the key is the last name. So you can directly choose one of these elements by writing the lastname. - -### Example 4: ### - -```luceescript -if(isNull(application.sex)) { - query name="application.sex" datasource="test" returntype="struct" columnKey="sex_id" { - echo(" - select sex_id,name from sex - "); - } -} -query name="qryPerson" datasource="test" { - echo(" - select sex_id,lastname,firstname from person - "); -} -loop query=qryPerson { - dump(qryPerson.lastname&" "&qryPerson.firstname&" ("&application.sex[qryPerson.sex_id].name&")"); -} -``` - -1) In this example we have two tables. We make a query to the ``person`` table. Notice that some fields are foreign key references too. We store ``sex_id`` in application scope because we use this on the second query. In this sex_id is the key of that struct, So we simply can address in ``("&application.sex[qryPerson.sex_id].name&")")`` this way. - -2) Execute this example in the browser and we get a result from the other table that is reference by a foreign key. - -### Footnotes ### - -You can see these details in the video here: - -[Query return type](https://www.youtube.com/watch?v=b9YHhnAuNiw) diff --git a/docs/04.guides/08.lucee-5/06.component-static/page.md b/docs/04.guides/08.lucee-5/06.component-static/page.md deleted file mode 100644 index 449878d23..000000000 --- a/docs/04.guides/08.lucee-5/06.component-static/page.md +++ /dev/null @@ -1,54 +0,0 @@ ---- -title: Static support for components -id: lucee-5-component-static -related: -- tag-component -categories: -- component -- scopes -- static -description: Lucee 5 supports static variables and functions inside components ---- - -# Static support for components # - -**Lucee 5 supports static variables and functions inside components.** - -Example: - -```luceescript -component { - // inside the static constructor you can define static variables, this code is executed when the "class" instance is loaded - static { - susi=1; // written to the static scope (defining the scope is not necessary) - static.sorglos=2; // again written to the static scope - } - - public static function testStatic() { - - } - - public function testInstance() { - static.testStatic(); // calling a static function - return static.sorglos; // returning data from the static scope - } -} -``` - -The "static" constructor `static {...}` is executed once before the component is loaded for the first time, so every component of the same type shares the same static scope. - -You can use static functions and data as follows. - -```luceescript -component Test { - static { - staticValue=1; - } - public static function testStatic(){} -} -``` - -```luceescript -Test::testStatic(); -x=Test:: staticValue; -``` diff --git a/docs/04.guides/08.lucee-5/07.dialect-lucee/page.md b/docs/04.guides/08.lucee-5/07.dialect-lucee/page.md index 388248fee..2581f852c 100644 --- a/docs/04.guides/08.lucee-5/07.dialect-lucee/page.md +++ b/docs/04.guides/08.lucee-5/07.dialect-lucee/page.md @@ -1,9 +1,13 @@ --- -title: The Lucee dialect +title: The Lucee dialect (removed 6.1) id: lucee-5-dialect-lucee +related: + - breaking-changes-6-0-to-6-1 --- # New Language dialect Lucee # +>>>>> The Lucee dialect was removed in 6.1, as it was barely used and removing it made Lucee faster for CFML + **In addition to the existing "CFML" language dialect, Lucee 5 comes with a completely new dialect simply called "Lucee".** The Lucee dialect is a light-weight dynamic scripting and tag language for the JVM that enables the rapid development of simple to highly sophisticated web applications. diff --git a/docs/05.categories/295.thread/category.md b/docs/05.categories/295.thread/category.md index 306132362..fb984344c 100644 --- a/docs/05.categories/295.thread/category.md +++ b/docs/05.categories/295.thread/category.md @@ -1,6 +1,9 @@ --- title: Threads id: category-thread +categories: +- scopes +description: Threads --- - [Easy Parallelism in Lucee](https://www.rasia.io/blog/easy-parallelism-in-lucee.html) diff --git a/docs/recipes/get-dbdriver-from-maven.md b/docs/recipes/get-dbdriver-from-maven.md index 34df78ce7..a48480ec6 100644 --- a/docs/recipes/get-dbdriver-from-maven.md +++ b/docs/recipes/get-dbdriver-from-maven.md @@ -9,6 +9,12 @@ "maven", "mysql" ,"db" + ], + "categories":[ + "query" + ], + "related": [ + "tag-query" ] } --> diff --git a/docs/recipes/thread-task.md b/docs/recipes/thread-task.md index 34dda69dd..1999a1dbd 100644 --- a/docs/recipes/thread-task.md +++ b/docs/recipes/thread-task.md @@ -1,9 +1,10 @@ -# Thread Task +# Thread Tasks This document explains about the thread tasks. It is useful to know the differences between regular threads and task threads. diff --git a/docs/recipes/thread-usage.md b/docs/recipes/thread-usage.md index 7b022c282..b1a265bf4 100644 --- a/docs/recipes/thread-usage.md +++ b/docs/recipes/thread-usage.md @@ -1,6 +1,6 @@ -# Thread Usage +# Using Threads in Lucee This document explains how to use threads in Lucee. Threads are mainly used for executing code in parallel. +Prior to Lucee 6.2, the thread scope wasn't an actual real scope, which led to some strange behavior, this has been resolved. + ## Example 1 The below example shows normal execution, waiting for all code to resolve. Here it takes 1000 milliseconds to complete the execution.